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 2020/03/26 02:41:26 UTC
[james-project] 04/16: JAMES-3088 Split AbstractUsersRepositoryTest
into two contracts
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 82bf5be86345c63829e7c6316dcb1f7379b23b6c
Author: Tran Tien Duc <dt...@linagora.com>
AuthorDate: Thu Mar 5 11:40:18 2020 +0700
JAMES-3088 Split AbstractUsersRepositoryTest into two contracts
---
.../user/lib/AbstractUsersRepositoryTest.java | 262 +++++++++++----------
.../user/memory/MemoryUsersRepositoryTest.java | 138 ++++++-----
2 files changed, 219 insertions(+), 181 deletions(-)
diff --git a/server/data/data-library/src/test/java/org/apache/james/user/lib/AbstractUsersRepositoryTest.java b/server/data/data-library/src/test/java/org/apache/james/user/lib/AbstractUsersRepositoryTest.java
index fe9e664..d959987 100644
--- a/server/data/data-library/src/test/java/org/apache/james/user/lib/AbstractUsersRepositoryTest.java
+++ b/server/data/data-library/src/test/java/org/apache/james/user/lib/AbstractUsersRepositoryTest.java
@@ -45,15 +45,25 @@ import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
+public interface AbstractUsersRepositoryTest {
-public abstract class AbstractUsersRepositoryTest {
+ class UserRepositoryExtension implements BeforeEachCallback, ParameterResolver {
- protected static class UserRepositoryExtension implements BeforeEachCallback, ParameterResolver {
+ private static final boolean ENABLE_VIRTUAL_HOSTING = true;
+ private static final boolean DISABLE_VIRTUAL_HOSTING = !ENABLE_VIRTUAL_HOSTING;
+
+ public static UserRepositoryExtension withVirtualHost() {
+ return new UserRepositoryExtension(ENABLE_VIRTUAL_HOSTING);
+ }
+
+ public static UserRepositoryExtension withoutVirtualHosting() {
+ return new UserRepositoryExtension(DISABLE_VIRTUAL_HOSTING);
+ }
private final boolean supportVirtualHosting;
private TestSystem testSystem;
- public UserRepositoryExtension(boolean supportVirtualHosting) {
+ private UserRepositoryExtension(boolean supportVirtualHosting) {
this.supportVirtualHosting = supportVirtualHosting;
}
@@ -73,7 +83,7 @@ public abstract class AbstractUsersRepositoryTest {
}
}
- protected static class TestSystem {
+ class TestSystem {
static final Domain DOMAIN = Domain.of("domain");
private final boolean supportVirtualHosting;
@@ -110,10 +120,76 @@ public abstract class AbstractUsersRepositoryTest {
}
}
- protected abstract AbstractUsersRepository testee();
-
+ interface WithVirtualHostingContract extends AbstractUsersRepositoryTest {
+
+ @Test
+ default void testShouldReturnTrueWhenAUserHasACorrectPasswordAndOtherCaseInDomain(TestSystem testSystem) throws Exception {
+ testSystem.domainList.addDomain(Domain.of("jAmEs.oRg"));
+ String username = "myuser";
+ String password = "password";
+ testee().addUser(Username.of(username + "@jAmEs.oRg"), password);
+
+ boolean actual = testee().test(Username.of(username + "@james.org"), password);
+
+ assertThat(actual).isTrue();
+ }
+
+ @Test
+ default void virtualHostedUsersRepositoryShouldUseFullMailAddressAsUsername() throws Exception {
+ // Some implementations do not support changing virtual hosting value
+ Assumptions.assumeTrue(testee().supportVirtualHosting());
+
+ assertThat(testee().getUsername(new MailAddress("local@domain"))).isEqualTo(Username.of("local@domain"));
+ }
+
+ @Test
+ default void getMailAddressForShouldBeIdentityWhenVirtualHosting() throws Exception {
+ // Some implementations do not support changing virtual hosting value
+ Assumptions.assumeTrue(testee().supportVirtualHosting());
+
+ String username = "user@domain";
+ assertThat(testee().getMailAddressFor(Username.of(username)))
+ .isEqualTo(username);
+ }
+
+ @Test
+ default void getUserShouldBeCaseInsensitive() throws Exception {
+ assertThat(testee().getUsername(new MailAddress("lowerUPPER", TestSystem.DOMAIN)))
+ .isEqualTo(Username.fromLocalPartWithDomain("lowerupper", TestSystem.DOMAIN));
+ }
+ }
+
+ interface WithOutVirtualHostingContract extends AbstractUsersRepositoryTest {
+ @Test
+ default void nonVirtualHostedUsersRepositoryShouldUseLocalPartAsUsername() throws Exception {
+ // Some implementations do not support changing virtual hosting value
+ Assumptions.assumeFalse(testee().supportVirtualHosting());
+
+ assertThat(testee().getUsername(new MailAddress("local@domain"))).isEqualTo(Username.of("local"));
+ }
+
+ @Test
+ default void getMailAddressForShouldAppendDefaultDomainWhenNoVirtualHosting(TestSystem testSystem) throws Exception {
+ // Some implementations do not support changing virtual hosting value
+ Assumptions.assumeFalse(testee().supportVirtualHosting());
+
+ String username = "user";
+ assertThat(testee().getMailAddressFor(Username.of(username)))
+ .isEqualTo(new MailAddress(username, testSystem.domainList.getDefaultDomain()));
+ }
+
+ @Test
+ default void getUserShouldBeCaseInsensitive() throws Exception {
+ assertThat(testee().getUsername(new MailAddress("lowerUPPER", TestSystem.DOMAIN)))
+ .isEqualTo(Username.fromLocalPartWithoutDomain("lowerupper"));
+ }
+
+ }
+
+ AbstractUsersRepository testee();
+
@Test
- void countUsersShouldReturnZeroWhenEmptyRepository() throws UsersRepositoryException {
+ default void countUsersShouldReturnZeroWhenEmptyRepository() throws UsersRepositoryException {
//Given
int expected = 0;
//When
@@ -121,9 +197,9 @@ public abstract class AbstractUsersRepositoryTest {
//Then
assertThat(actual).isEqualTo(expected);
}
-
+
@Test
- void countUsersShouldReturnNumberOfUsersWhenNotEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
+ default void countUsersShouldReturnNumberOfUsersWhenNotEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
ArrayList<Username> keys = new ArrayList<>(3);
keys.add(testSystem.user1);
@@ -137,9 +213,9 @@ public abstract class AbstractUsersRepositoryTest {
//Then
assertThat(actual).isEqualTo(keys.size());
}
-
+
@Test
- void listShouldReturnEmptyIteratorWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
+ default void listShouldReturnEmptyIteratorWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
//When
Iterator<Username> actual = testee().list();
//Then
@@ -147,9 +223,9 @@ public abstract class AbstractUsersRepositoryTest {
.toIterable()
.isEmpty();
}
-
+
@Test
- void listShouldReturnExactlyUsersInRepository(TestSystem testSystem) throws UsersRepositoryException {
+ default void listShouldReturnExactlyUsersInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
ArrayList<Username> keys = new ArrayList<>(3);
keys.add(testSystem.user1);
@@ -165,9 +241,9 @@ public abstract class AbstractUsersRepositoryTest {
.toIterable()
.containsOnly(testSystem.user1, testSystem.user2, testSystem.user3);
}
-
+
@Test
- void addUserShouldAddAUserWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
+ default void addUserShouldAddAUserWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
//When
testee().addUser(testSystem.user2, "password2");
//Then
@@ -175,28 +251,28 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void containsShouldPreserveCaseVariation(TestSystem testSystem) throws UsersRepositoryException {
+ default void containsShouldPreserveCaseVariation(TestSystem testSystem) throws UsersRepositoryException {
testee().addUser(testSystem.user1CaseVariation, "password2");
assertThat(testee().contains(testSystem.user1CaseVariation)).isTrue();
}
@Test
- void containsShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
+ default void containsShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
testee().addUser(testSystem.user1CaseVariation, "password2");
assertThat(testee().contains(testSystem.user1)).isTrue();
}
@Test
- void containsShouldBeCaseInsentiveWhenOriginalValueLowerCased(TestSystem testSystem) throws UsersRepositoryException {
+ default void containsShouldBeCaseInsentiveWhenOriginalValueLowerCased(TestSystem testSystem) throws UsersRepositoryException {
testee().addUser(testSystem.user1, "password2");
assertThat(testee().contains(testSystem.user1CaseVariation)).isTrue();
}
@Test
- void addUserShouldDisableCaseVariationWhenOriginalValueLowerCased(TestSystem testSystem) throws UsersRepositoryException {
+ default void addUserShouldDisableCaseVariationWhenOriginalValueLowerCased(TestSystem testSystem) throws UsersRepositoryException {
testee().addUser(testSystem.user1, "password2");
assertThatThrownBy(() -> testee().addUser(testSystem.user1CaseVariation, "pass"))
@@ -204,7 +280,7 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void addUserShouldDisableCaseVariation(TestSystem testSystem) throws UsersRepositoryException {
+ default void addUserShouldDisableCaseVariation(TestSystem testSystem) throws UsersRepositoryException {
testee().addUser(testSystem.user1CaseVariation, "password2");
assertThatThrownBy(() -> testee().addUser(testSystem.user1, "pass"))
@@ -212,7 +288,7 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void listShouldReturnLowerCaseUser(TestSystem testSystem) throws UsersRepositoryException {
+ default void listShouldReturnLowerCaseUser(TestSystem testSystem) throws UsersRepositoryException {
testee().addUser(testSystem.user1CaseVariation, "password2");
assertThat(testee().list())
@@ -221,7 +297,7 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void removeUserShouldBeCaseInsentiveOnCaseVariationUser(TestSystem testSystem) throws UsersRepositoryException {
+ default void removeUserShouldBeCaseInsentiveOnCaseVariationUser(TestSystem testSystem) throws UsersRepositoryException {
testee().addUser(testSystem.user1CaseVariation, "password2");
testee().removeUser(testSystem.user1);
@@ -232,7 +308,7 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void removeUserShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
+ default void removeUserShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
testee().addUser(testSystem.user1, "password2");
testee().removeUser(testSystem.user1CaseVariation);
@@ -243,7 +319,7 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void getUserByNameShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
+ default void getUserByNameShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
testee().addUser(testSystem.user1, "password2");
assertThat(testee().getUserByName(testSystem.user1CaseVariation).getUserName())
@@ -251,7 +327,7 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void getUserByNameShouldReturnLowerCaseAddedUser(TestSystem testSystem) throws UsersRepositoryException {
+ default void getUserByNameShouldReturnLowerCaseAddedUser(TestSystem testSystem) throws UsersRepositoryException {
testee().addUser(testSystem.user1CaseVariation, "password2");
assertThat(testee().getUserByName(testSystem.user1).getUserName())
@@ -259,20 +335,20 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void getUserShouldBeCaseInsentive(TestSystem testSystem) throws Exception {
+ default void getUserShouldBeCaseInsentive(TestSystem testSystem) throws Exception {
assertThat(testee().getUsername(testSystem.user1CaseVariation.asMailAddress()))
.isEqualTo(testSystem.user1);
}
@Test
- void isAdministratorShouldBeCaseInsentive(TestSystem testSystem) throws Exception {
+ default void isAdministratorShouldBeCaseInsentive(TestSystem testSystem) throws Exception {
testee().setAdministratorId(Optional.of(testSystem.admin));
assertThat(testee().isAdministrator(testSystem.adminCaseVariation))
.isTrue();
}
@Test
- void testShouldBeCaseInsentiveOnCaseVariationUser(TestSystem testSystem) throws UsersRepositoryException {
+ default void testShouldBeCaseInsentiveOnCaseVariationUser(TestSystem testSystem) throws UsersRepositoryException {
String password = "password2";
testee().addUser(testSystem.user1CaseVariation, password);
@@ -281,16 +357,16 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void testShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
+ default void testShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
String password = "password2";
testee().addUser(testSystem.user1, password);
assertThat(testee().test(testSystem.user1CaseVariation, password))
.isTrue();
}
-
- @Test
- void addUserShouldAddAUserWhenNotEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
+
+ @Test
+ default void addUserShouldAddAUserWhenNotEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.user2, "password2");
//When
@@ -298,27 +374,27 @@ public abstract class AbstractUsersRepositoryTest {
//Then
assertThat(testee().contains(testSystem.user3)).isTrue();
}
-
+
@Test
- void addUserShouldThrowWhenSameUsernameWithDifferentCase(TestSystem testSystem) throws UsersRepositoryException {
+ default void addUserShouldThrowWhenSameUsernameWithDifferentCase(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.toUsername("myUsername"), "password");
//When
assertThatThrownBy(() -> testee().addUser(testSystem.toUsername("MyUsername"), "password"))
.isInstanceOf(AlreadyExistInUsersRepositoryException.class);
}
-
+
@Test
- void addUserShouldThrowWhenUserAlreadyPresentInRepository(TestSystem testSystem) throws UsersRepositoryException {
+ default void addUserShouldThrowWhenUserAlreadyPresentInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.user1, "password");
//When
assertThatThrownBy(() -> testee().addUser(testSystem.user1, "password2"))
.isInstanceOf(AlreadyExistInUsersRepositoryException.class);
}
-
+
@Test
- void getUserByNameShouldReturnAUserWhenContainedInRepository(TestSystem testSystem) throws UsersRepositoryException {
+ default void getUserByNameShouldReturnAUserWhenContainedInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.user1, "password");
//When
@@ -329,7 +405,7 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void getUserByNameShouldReturnUserWhenDifferentCase(TestSystem testSystem) throws UsersRepositoryException {
+ default void getUserByNameShouldReturnUserWhenDifferentCase(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.toUsername("username"), "password");
//When
@@ -338,9 +414,9 @@ public abstract class AbstractUsersRepositoryTest {
assertThat(actual).isNotNull();
assertThat(actual.getUserName()).isEqualTo(testSystem.user1);
}
-
+
@Test
- void testShouldReturnTrueWhenAUserHasACorrectPassword(TestSystem testSystem) throws UsersRepositoryException {
+ default void testShouldReturnTrueWhenAUserHasACorrectPassword(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.user1, "password");
//When
@@ -348,23 +424,9 @@ public abstract class AbstractUsersRepositoryTest {
//Then
assertThat(actual).isTrue();
}
-
- @Test
- void testShouldReturnTrueWhenAUserHasACorrectPasswordAndOtherCaseInDomain(TestSystem testSystem) throws Exception {
- testee().setEnableVirtualHosting(true);
-
- testSystem.domainList.addDomain(Domain.of("jAmEs.oRg"));
- String username = "myuser";
- String password = "password";
- testee().addUser(Username.of(username + "@jAmEs.oRg"), password);
-
- boolean actual = testee().test(Username.of(username + "@james.org"), password);
-
- assertThat(actual).isTrue();
- }
@Test
- void testShouldReturnFalseWhenAUserHasAnIncorrectPassword(TestSystem testSystem) throws UsersRepositoryException {
+ default void testShouldReturnFalseWhenAUserHasAnIncorrectPassword(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.user1, "password");
//When
@@ -372,9 +434,9 @@ public abstract class AbstractUsersRepositoryTest {
//Then
assertThat(actual).isFalse();
}
-
+
@Test
- void testShouldReturnFalseWhenAUserHasAnIncorrectCasePassword(TestSystem testSystem) throws UsersRepositoryException {
+ default void testShouldReturnFalseWhenAUserHasAnIncorrectCasePassword(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.user1, "password");
//When
@@ -382,9 +444,9 @@ public abstract class AbstractUsersRepositoryTest {
//Then
assertThat(actual).isFalse();
}
-
+
@Test
- void testShouldReturnFalseWhenAUserIsNotInRepository(TestSystem testSystem) throws UsersRepositoryException {
+ default void testShouldReturnFalseWhenAUserIsNotInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.toUsername("username"), "password");
//When
@@ -394,7 +456,7 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void testShouldReturnTrueWhenAUserHasAnIncorrectCaseName(TestSystem testSystem) throws UsersRepositoryException {
+ default void testShouldReturnTrueWhenAUserHasAnIncorrectCaseName(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.toUsername("username"), "password");
//When
@@ -404,7 +466,7 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void testShouldReturnFalseWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
+ default void testShouldReturnFalseWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
//When
boolean actual = testee().test(testSystem.user1, "password");
//Then
@@ -412,7 +474,7 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void testShouldReturnFalseWhenAUserIsRemovedFromRepository(TestSystem testSystem) throws UsersRepositoryException {
+ default void testShouldReturnFalseWhenAUserIsRemovedFromRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.user1, "password");
testee().removeUser(testSystem.user1);
@@ -421,9 +483,9 @@ public abstract class AbstractUsersRepositoryTest {
//Then
assertThat(actual).isFalse();
}
-
+
@Test
- void removeUserShouldRemoveAUserWhenPresentInRepository(TestSystem testSystem) throws UsersRepositoryException {
+ default void removeUserShouldRemoveAUserWhenPresentInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.user1, "password");
//When
@@ -431,16 +493,16 @@ public abstract class AbstractUsersRepositoryTest {
//Then
assertThat(testee().contains(testSystem.user1)).isFalse();
}
-
+
@Test
- void removeUserShouldThrowWhenUserNotInRepository(TestSystem testSystem) {
+ default void removeUserShouldThrowWhenUserNotInRepository(TestSystem testSystem) {
//When
assertThatThrownBy(() -> testee().removeUser(testSystem.user1))
.isInstanceOf(UsersRepositoryException.class);
}
-
+
@Test
- void updateUserShouldAllowToAuthenticateWithNewPassword(TestSystem testSystem) throws UsersRepositoryException {
+ default void updateUserShouldAllowToAuthenticateWithNewPassword(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.user1, "password");
User user = testee().getUserByName(testSystem.user1);
@@ -450,9 +512,9 @@ public abstract class AbstractUsersRepositoryTest {
//Then
assertThat(testee().test(testSystem.user1, "newpass")).isTrue();
}
-
+
@Test
- void updateUserShouldNotAllowToAuthenticateWithOldPassword(TestSystem testSystem) throws UsersRepositoryException {
+ default void updateUserShouldNotAllowToAuthenticateWithOldPassword(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.user1, "password");
User user = testee().getUserByName(testSystem.user1);
@@ -462,9 +524,9 @@ public abstract class AbstractUsersRepositoryTest {
//Then
assertThat(testee().test(testSystem.user1, "password")).isFalse();
}
-
+
@Test
- void updateUserShouldThrowWhenAUserIsNoMoreInRepository(TestSystem testSystem) throws UsersRepositoryException {
+ default void updateUserShouldThrowWhenAUserIsNoMoreInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
testee().addUser(testSystem.user1, "password");
User user = testee().getUserByName(testSystem.user1);
@@ -475,78 +537,34 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void virtualHostedUsersRepositoryShouldUseFullMailAddressAsUsername() throws Exception {
- testee().setEnableVirtualHosting(true);
-
- // Some implementations do not support changing virtual hosting value
- Assumptions.assumeTrue(testee().supportVirtualHosting());
-
- assertThat(testee().getUsername(new MailAddress("local@domain"))).isEqualTo(Username.of("local@domain"));
- }
-
- @Test
- void nonVirtualHostedUsersRepositoryShouldUseLocalPartAsUsername() throws Exception {
- testee().setEnableVirtualHosting(false);
-
- // Some implementations do not support changing virtual hosting value
- Assumptions.assumeFalse(testee().supportVirtualHosting());
-
- assertThat(testee().getUsername(new MailAddress("local@domain"))).isEqualTo(Username.of("local"));
- }
-
- @Test
- void isAdministratorShouldReturnFalseWhenNotConfigured(TestSystem testSystem) throws Exception {
+ default void isAdministratorShouldReturnFalseWhenNotConfigured(TestSystem testSystem) throws Exception {
testee().setAdministratorId(Optional.empty());
assertThat(testee().isAdministrator(testSystem.admin)).isFalse();
}
@Test
- void isAdministratorShouldReturnTrueWhenConfiguredAndUserIsAdmin(TestSystem testSystem) throws Exception {
+ default void isAdministratorShouldReturnTrueWhenConfiguredAndUserIsAdmin(TestSystem testSystem) throws Exception {
testee().setAdministratorId(Optional.of(testSystem.admin));
assertThat(testee().isAdministrator(testSystem.admin)).isTrue();
}
@Test
- void isAdministratorShouldReturnFalseWhenConfiguredAndUserIsNotAdmin(TestSystem testSystem) throws Exception {
+ default void isAdministratorShouldReturnFalseWhenConfiguredAndUserIsNotAdmin(TestSystem testSystem) throws Exception {
testee().setAdministratorId(Optional.of(testSystem.admin));
assertThat(testee().isAdministrator(testSystem.user1)).isFalse();
}
- @Test
- void getMailAddressForShouldBeIdentityWhenVirtualHosting() throws Exception {
- testee().setEnableVirtualHosting(true);
-
- // Some implementations do not support changing virtual hosting value
- Assumptions.assumeTrue(testee().supportVirtualHosting());
-
- String username = "user@domain";
- assertThat(testee().getMailAddressFor(Username.of(username)))
- .isEqualTo(username);
- }
-
- @Test
- void getMailAddressForShouldAppendDefaultDomainWhenNoVirtualHosting(TestSystem testSystem) throws Exception {
- testee().setEnableVirtualHosting(false);
-
- // Some implementations do not support changing virtual hosting value
- Assumptions.assumeFalse(testee().supportVirtualHosting());
-
- String username = "user";
- assertThat(testee().getMailAddressFor(Username.of(username)))
- .isEqualTo(new MailAddress(username, testSystem.domainList.getDefaultDomain()));
- }
-
@ParameterizedTest
@MethodSource("illegalCharacters")
- void assertValidShouldThrowWhenUsernameLocalPartWithIllegalCharacter(String illegalCharacter) {
+ default void assertValidShouldThrowWhenUsernameLocalPartWithIllegalCharacter(String illegalCharacter) {
assertThatThrownBy(() -> testee().assertValid(Username.of("a" + illegalCharacter + "a")))
.isInstanceOf(InvalidUsernameException.class);
}
- private static Stream<Arguments> illegalCharacters() {
+ static Stream<Arguments> illegalCharacters() {
return Stream.of(
"\"",
"(",
diff --git a/server/data/data-memory/src/test/java/org/apache/james/user/memory/MemoryUsersRepositoryTest.java b/server/data/data-memory/src/test/java/org/apache/james/user/memory/MemoryUsersRepositoryTest.java
index 54ddc17..51cc61e 100644
--- a/server/data/data-memory/src/test/java/org/apache/james/user/memory/MemoryUsersRepositoryTest.java
+++ b/server/data/data-memory/src/test/java/org/apache/james/user/memory/MemoryUsersRepositoryTest.java
@@ -30,76 +30,96 @@ import org.apache.james.user.api.UsersRepositoryException;
import org.apache.james.user.lib.AbstractUsersRepository;
import org.apache.james.user.lib.AbstractUsersRepositoryTest;
import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
-class MemoryUsersRepositoryTest extends AbstractUsersRepositoryTest {
-
- @RegisterExtension
- static UserRepositoryExtension extension = new UserRepositoryExtension(true);
-
- private MemoryUsersRepository memoryUsersRepository;
-
- @BeforeEach
- void setUp(TestSystem testSystem) {
- memoryUsersRepository = MemoryUsersRepository.withVirtualHosting(testSystem.getDomainList());
+class MemoryUsersRepositoryTest {
+
+ @Nested
+ class WhenEnableVirtualHosting implements AbstractUsersRepositoryTest.WithVirtualHostingContract {
+ @RegisterExtension
+ UserRepositoryExtension extension = UserRepositoryExtension.withVirtualHost();
+
+ private MemoryUsersRepository memoryUsersRepository;
+
+ @BeforeEach
+ void setUp(TestSystem testSystem) {
+ memoryUsersRepository = MemoryUsersRepository.withVirtualHosting(testSystem.getDomainList());
+ }
+
+ @Override
+ public AbstractUsersRepository testee() {
+ return memoryUsersRepository;
+ }
+
+ @Test
+ void assertValidShouldThrowWhenNoDomainPartAndVirtualHosting() {
+ assertThatThrownBy(() -> memoryUsersRepository.assertValid(Username.of("user")))
+ .isInstanceOf(UsersRepositoryException.class);
+ }
+
+ @Test
+ void assertValidShouldNotThrowWhenDomainPartAndVirtualHosting() throws Exception {
+ MemoryDomainList domainList = new MemoryDomainList(new InMemoryDNSService()
+ .registerMxRecord("localhost", "127.0.0.1")
+ .registerMxRecord("127.0.0.1", "127.0.0.1"));
+ domainList.setAutoDetect(false);
+ domainList.setAutoDetectIP(false);
+ domainList.addDomain(Domain.of("domain.tld"));
+
+ MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withVirtualHosting(domainList);
+
+ assertThatCode(() -> memoryUsersRepository.assertValid(Username.of("user@domain.tld")))
+ .doesNotThrowAnyException();
+ }
+
+ @Test
+ void assertValidShouldNotThrowWhenDomainPartAndDomainNotFound() throws Exception {
+ MemoryDomainList domainList = new MemoryDomainList(new InMemoryDNSService()
+ .registerMxRecord("localhost", "127.0.0.1")
+ .registerMxRecord("127.0.0.1", "127.0.0.1"));
+ domainList.setAutoDetect(false);
+ domainList.setAutoDetectIP(false);
+
+ MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withVirtualHosting(domainList);
+
+ assertThatThrownBy(() -> memoryUsersRepository.assertValid(Username.of("user@domain.tld")))
+ .isInstanceOf(UsersRepositoryException.class);
+ }
}
- @Override
- protected AbstractUsersRepository testee() {
- return memoryUsersRepository;
- }
+ @Nested
+ class WhenDisableVirtualHosting implements AbstractUsersRepositoryTest.WithOutVirtualHostingContract {
+ @RegisterExtension
+ UserRepositoryExtension extension = UserRepositoryExtension.withoutVirtualHosting();
- @Test
- void assertValidShouldThrowWhenDomainPartAndNoVirtualHosting(TestSystem testSystem) {
- MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withoutVirtualHosting(testSystem.getDomainList());
+ private MemoryUsersRepository memoryUsersRepository;
- assertThatThrownBy(() -> memoryUsersRepository.assertValid(Username.of("user@domain.tld")))
- .isInstanceOf(UsersRepositoryException.class);
- }
-
- @Test
- void assertValidShouldThrowWhenNoDomainPartAndVirtualHosting(TestSystem testSystem) {
- MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withVirtualHosting(testSystem.getDomainList());
+ @BeforeEach
+ void setUp(TestSystem testSystem) {
+ memoryUsersRepository = MemoryUsersRepository.withoutVirtualHosting(testSystem.getDomainList());
+ }
- assertThatThrownBy(() -> memoryUsersRepository.assertValid(Username.of("user")))
- .isInstanceOf(UsersRepositoryException.class);
- }
+ @Override
+ public AbstractUsersRepository testee() {
+ return memoryUsersRepository;
+ }
- @Test
- void assertValidShouldNotThrowWhenDomainPartAndVirtualHosting() throws Exception {
- MemoryDomainList domainList = new MemoryDomainList(new InMemoryDNSService()
- .registerMxRecord("localhost", "127.0.0.1")
- .registerMxRecord("127.0.0.1", "127.0.0.1"));
- domainList.setAutoDetect(false);
- domainList.setAutoDetectIP(false);
- domainList.addDomain(Domain.of("domain.tld"));
+ @Test
+ void assertValidShouldThrowWhenDomainPartAndNoVirtualHosting(TestSystem testSystem) {
+ MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withoutVirtualHosting(testSystem.getDomainList());
- MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withVirtualHosting(domainList);
-
- assertThatCode(() -> memoryUsersRepository.assertValid(Username.of("user@domain.tld")))
- .doesNotThrowAnyException();
- }
-
- @Test
- void assertValidShouldNotThrowWhenDomainPartAndDomainNotFound() throws Exception {
- MemoryDomainList domainList = new MemoryDomainList(new InMemoryDNSService()
- .registerMxRecord("localhost", "127.0.0.1")
- .registerMxRecord("127.0.0.1", "127.0.0.1"));
- domainList.setAutoDetect(false);
- domainList.setAutoDetectIP(false);
-
- MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withVirtualHosting(domainList);
-
- assertThatThrownBy(() -> memoryUsersRepository.assertValid(Username.of("user@domain.tld")))
- .isInstanceOf(UsersRepositoryException.class);
- }
+ assertThatThrownBy(() -> memoryUsersRepository.assertValid(Username.of("user@domain.tld")))
+ .isInstanceOf(UsersRepositoryException.class);
+ }
- @Test
- void assertValidShouldNotThrowWhenNoDomainPartAndNoVirtualHosting(TestSystem testSystem) {
- MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withoutVirtualHosting(testSystem.getDomainList());
+ @Test
+ void assertValidShouldNotThrowWhenNoDomainPartAndNoVirtualHosting(TestSystem testSystem) {
+ MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withoutVirtualHosting(testSystem.getDomainList());
- assertThatCode(() -> memoryUsersRepository.assertValid(Username.of("user")))
- .doesNotThrowAnyException();
+ assertThatCode(() -> memoryUsersRepository.assertValid(Username.of("user")))
+ .doesNotThrowAnyException();
+ }
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscribe@james.apache.org
For additional commands, e-mail: server-dev-help@james.apache.org