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:25 UTC
[james-project] 03/16: JAMES-3088 Migrating UserRepository tests to
Junit 5 contract style
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 050b0adcd4aafc79ec43ff2de2baa69bb639f070
Author: Tran Tien Duc <dt...@linagora.com>
AuthorDate: Thu Mar 5 11:04:59 2020 +0700
JAMES-3088 Migrating UserRepository tests to Junit 5 contract style
This is a `have to` step in order to test every method with and without
virtualHosting. It requires to have separated contracts implementing
the common one. The different is only about virtualHosting support.
Otherwise, with the incoming number of tests regarding this issue.
The test code will be really messy. And we cannot easy to test the LDAP
version because it doesn't implement the abstract test right now
Memory version go first
---
.../user/lib/AbstractUsersRepositoryTest.java | 416 +++++++++++----------
.../user/memory/MemoryUsersRepositoryTest.java | 28 +-
2 files changed, 237 insertions(+), 207 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 a5f056c..fe9e664 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
@@ -30,13 +30,17 @@ import org.apache.james.core.Domain;
import org.apache.james.core.MailAddress;
import org.apache.james.core.Username;
import org.apache.james.domainlist.api.mock.SimpleDomainList;
-import org.apache.james.lifecycle.api.LifecycleUtil;
import org.apache.james.user.api.AlreadyExistInUsersRepositoryException;
import org.apache.james.user.api.InvalidUsernameException;
import org.apache.james.user.api.UsersRepositoryException;
import org.apache.james.user.api.model.User;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
@@ -44,80 +48,100 @@ import org.junit.jupiter.params.provider.MethodSource;
public abstract class AbstractUsersRepositoryTest {
- static final Domain DOMAIN = Domain.of("domain");
-
- protected AbstractUsersRepository usersRepository;
- protected SimpleDomainList domainList;
-
- /**
- * Create the repository to be tested.
- *
- * @return the user repository
- * @throws Exception
- */
- protected abstract AbstractUsersRepository getUsersRepository() throws Exception;
-
- Username user1;
- Username user1CaseVariation;
- Username user2;
- Username user3;
- Username admin;
- Username adminCaseVariation;
-
- protected void setUp() throws Exception {
- domainList = new SimpleDomainList();
- domainList.addDomain(DOMAIN);
- this.usersRepository = getUsersRepository();
- user1 = login("username");
- user2 = login("username2");
- user3 = login("username3");
- user1CaseVariation = login("uSeRnaMe");
- admin = login("admin");
- adminCaseVariation = login("adMin");
- }
-
- protected void tearDown() throws Exception {
- LifecycleUtil.dispose(this.usersRepository);
+ protected static class UserRepositoryExtension implements BeforeEachCallback, ParameterResolver {
+
+ private final boolean supportVirtualHosting;
+ private TestSystem testSystem;
+
+ public UserRepositoryExtension(boolean supportVirtualHosting) {
+ this.supportVirtualHosting = supportVirtualHosting;
+ }
+
+ @Override
+ public void beforeEach(ExtensionContext extensionContext) throws Exception {
+ testSystem = new TestSystem(supportVirtualHosting);
+ }
+
+ @Override
+ public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
+ return parameterContext.getParameter().getType() == TestSystem.class;
+ }
+
+ @Override
+ public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
+ return testSystem;
+ }
}
-
- private Username login(String login) {
- if (usersRepository.supportVirtualHosting()) {
- return Username.of(login + '@' + DOMAIN.name());
- } else {
- return Username.of(login);
+
+ protected static class TestSystem {
+ static final Domain DOMAIN = Domain.of("domain");
+
+ private final boolean supportVirtualHosting;
+ private final SimpleDomainList domainList;
+ private final Username user1;
+ private final Username user1CaseVariation;
+ private final Username user2;
+ private final Username user3;
+ private final Username admin;
+ private final Username adminCaseVariation;
+
+ TestSystem(boolean supportVirtualHosting) throws Exception {
+ this.supportVirtualHosting = supportVirtualHosting;
+ domainList = new SimpleDomainList();
+ domainList.addDomain(DOMAIN);
+ user1 = toUsername("username");
+ user2 = toUsername("username2");
+ user3 = toUsername("username3");
+ user1CaseVariation = toUsername("uSeRnaMe");
+ admin = toUsername("testSystem.admin");
+ adminCaseVariation = toUsername("testSystem.admin");
+ }
+
+ private Username toUsername(String login) {
+ if (supportVirtualHosting) {
+ return Username.of(login + '@' + DOMAIN.name());
+ } else {
+ return Username.of(login);
+ }
+ }
+
+ public SimpleDomainList getDomainList() {
+ return domainList;
}
}
+
+ protected abstract AbstractUsersRepository testee();
@Test
void countUsersShouldReturnZeroWhenEmptyRepository() throws UsersRepositoryException {
//Given
int expected = 0;
//When
- int actual = usersRepository.countUsers();
+ int actual = testee().countUsers();
//Then
assertThat(actual).isEqualTo(expected);
}
@Test
- void countUsersShouldReturnNumberOfUsersWhenNotEmptyRepository() throws UsersRepositoryException {
+ void countUsersShouldReturnNumberOfUsersWhenNotEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
ArrayList<Username> keys = new ArrayList<>(3);
- keys.add(user1);
- keys.add(user2);
- keys.add(user3);
+ keys.add(testSystem.user1);
+ keys.add(testSystem.user2);
+ keys.add(testSystem.user3);
for (Username username : keys) {
- usersRepository.addUser(username, username.asString());
+ testee().addUser(username, username.asString());
}
//When
- int actual = usersRepository.countUsers();
+ int actual = testee().countUsers();
//Then
assertThat(actual).isEqualTo(keys.size());
}
@Test
- void listShouldReturnEmptyIteratorWhenEmptyRepository() throws UsersRepositoryException {
+ void listShouldReturnEmptyIteratorWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
//When
- Iterator<Username> actual = usersRepository.list();
+ Iterator<Username> actual = testee().list();
//Then
assertThat(actual)
.toIterable()
@@ -125,400 +149,400 @@ public abstract class AbstractUsersRepositoryTest {
}
@Test
- void listShouldReturnExactlyUsersInRepository() throws UsersRepositoryException {
+ void listShouldReturnExactlyUsersInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
ArrayList<Username> keys = new ArrayList<>(3);
- keys.add(user1);
- keys.add(user2);
- keys.add(user3);
+ keys.add(testSystem.user1);
+ keys.add(testSystem.user2);
+ keys.add(testSystem.user3);
for (Username username : keys) {
- usersRepository.addUser(username, username.asString());
+ testee().addUser(username, username.asString());
}
//When
- Iterator<Username> actual = usersRepository.list();
+ Iterator<Username> actual = testee().list();
//Then
assertThat(actual)
.toIterable()
- .containsOnly(user1, user2, user3);
+ .containsOnly(testSystem.user1, testSystem.user2, testSystem.user3);
}
@Test
- void addUserShouldAddAUserWhenEmptyRepository() throws UsersRepositoryException {
+ void addUserShouldAddAUserWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
//When
- usersRepository.addUser(user2, "password2");
+ testee().addUser(testSystem.user2, "password2");
//Then
- assertThat(usersRepository.contains(user2)).isTrue();
+ assertThat(testee().contains(testSystem.user2)).isTrue();
}
@Test
- void containsShouldPreserveCaseVariation() throws UsersRepositoryException {
- usersRepository.addUser(user1CaseVariation, "password2");
+ void containsShouldPreserveCaseVariation(TestSystem testSystem) throws UsersRepositoryException {
+ testee().addUser(testSystem.user1CaseVariation, "password2");
- assertThat(usersRepository.contains(user1CaseVariation)).isTrue();
+ assertThat(testee().contains(testSystem.user1CaseVariation)).isTrue();
}
@Test
- void containsShouldBeCaseInsentive() throws UsersRepositoryException {
- usersRepository.addUser(user1CaseVariation, "password2");
+ void containsShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
+ testee().addUser(testSystem.user1CaseVariation, "password2");
- assertThat(usersRepository.contains(user1)).isTrue();
+ assertThat(testee().contains(testSystem.user1)).isTrue();
}
@Test
- void containsShouldBeCaseInsentiveWhenOriginalValueLowerCased() throws UsersRepositoryException {
- usersRepository.addUser(user1, "password2");
+ void containsShouldBeCaseInsentiveWhenOriginalValueLowerCased(TestSystem testSystem) throws UsersRepositoryException {
+ testee().addUser(testSystem.user1, "password2");
- assertThat(usersRepository.contains(user1CaseVariation)).isTrue();
+ assertThat(testee().contains(testSystem.user1CaseVariation)).isTrue();
}
@Test
- void addUserShouldDisableCaseVariationWhenOriginalValueLowerCased() throws UsersRepositoryException {
- usersRepository.addUser(user1, "password2");
+ void addUserShouldDisableCaseVariationWhenOriginalValueLowerCased(TestSystem testSystem) throws UsersRepositoryException {
+ testee().addUser(testSystem.user1, "password2");
- assertThatThrownBy(() -> usersRepository.addUser(user1CaseVariation, "pass"))
+ assertThatThrownBy(() -> testee().addUser(testSystem.user1CaseVariation, "pass"))
.isInstanceOf(UsersRepositoryException.class);
}
@Test
- void addUserShouldDisableCaseVariation() throws UsersRepositoryException {
- usersRepository.addUser(user1CaseVariation, "password2");
+ void addUserShouldDisableCaseVariation(TestSystem testSystem) throws UsersRepositoryException {
+ testee().addUser(testSystem.user1CaseVariation, "password2");
- assertThatThrownBy(() -> usersRepository.addUser(user1, "pass"))
+ assertThatThrownBy(() -> testee().addUser(testSystem.user1, "pass"))
.isInstanceOf(UsersRepositoryException.class);
}
@Test
- void listShouldReturnLowerCaseUser() throws UsersRepositoryException {
- usersRepository.addUser(user1CaseVariation, "password2");
+ void listShouldReturnLowerCaseUser(TestSystem testSystem) throws UsersRepositoryException {
+ testee().addUser(testSystem.user1CaseVariation, "password2");
- assertThat(usersRepository.list())
+ assertThat(testee().list())
.toIterable()
- .containsExactly(user1);
+ .containsExactly(testSystem.user1);
}
@Test
- void removeUserShouldBeCaseInsentiveOnCaseVariationUser() throws UsersRepositoryException {
- usersRepository.addUser(user1CaseVariation, "password2");
+ void removeUserShouldBeCaseInsentiveOnCaseVariationUser(TestSystem testSystem) throws UsersRepositoryException {
+ testee().addUser(testSystem.user1CaseVariation, "password2");
- usersRepository.removeUser(user1);
+ testee().removeUser(testSystem.user1);
- assertThat(usersRepository.list())
+ assertThat(testee().list())
.toIterable()
.isEmpty();
}
@Test
- void removeUserShouldBeCaseInsentive() throws UsersRepositoryException {
- usersRepository.addUser(user1, "password2");
+ void removeUserShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
+ testee().addUser(testSystem.user1, "password2");
- usersRepository.removeUser(user1CaseVariation);
+ testee().removeUser(testSystem.user1CaseVariation);
- assertThat(usersRepository.list())
+ assertThat(testee().list())
.toIterable()
.isEmpty();
}
@Test
- void getUserByNameShouldBeCaseInsentive() throws UsersRepositoryException {
- usersRepository.addUser(user1, "password2");
+ void getUserByNameShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
+ testee().addUser(testSystem.user1, "password2");
- assertThat(usersRepository.getUserByName(user1CaseVariation).getUserName())
- .isEqualTo(user1);
+ assertThat(testee().getUserByName(testSystem.user1CaseVariation).getUserName())
+ .isEqualTo(testSystem.user1);
}
@Test
- void getUserByNameShouldReturnLowerCaseAddedUser() throws UsersRepositoryException {
- usersRepository.addUser(user1CaseVariation, "password2");
+ void getUserByNameShouldReturnLowerCaseAddedUser(TestSystem testSystem) throws UsersRepositoryException {
+ testee().addUser(testSystem.user1CaseVariation, "password2");
- assertThat(usersRepository.getUserByName(user1).getUserName())
- .isEqualTo(user1);
+ assertThat(testee().getUserByName(testSystem.user1).getUserName())
+ .isEqualTo(testSystem.user1);
}
@Test
- void getUserShouldBeCaseInsentive() throws Exception {
- assertThat(usersRepository.getUsername(user1CaseVariation.asMailAddress()))
- .isEqualTo(user1);
+ void getUserShouldBeCaseInsentive(TestSystem testSystem) throws Exception {
+ assertThat(testee().getUsername(testSystem.user1CaseVariation.asMailAddress()))
+ .isEqualTo(testSystem.user1);
}
@Test
- void isAdministratorShouldBeCaseInsentive() throws Exception {
- usersRepository.setAdministratorId(Optional.of(admin));
- assertThat(usersRepository.isAdministrator(adminCaseVariation))
+ void isAdministratorShouldBeCaseInsentive(TestSystem testSystem) throws Exception {
+ testee().setAdministratorId(Optional.of(testSystem.admin));
+ assertThat(testee().isAdministrator(testSystem.adminCaseVariation))
.isTrue();
}
@Test
- void testShouldBeCaseInsentiveOnCaseVariationUser() throws UsersRepositoryException {
+ void testShouldBeCaseInsentiveOnCaseVariationUser(TestSystem testSystem) throws UsersRepositoryException {
String password = "password2";
- usersRepository.addUser(user1CaseVariation, password);
+ testee().addUser(testSystem.user1CaseVariation, password);
- assertThat(usersRepository.test(user1, password))
+ assertThat(testee().test(testSystem.user1, password))
.isTrue();
}
@Test
- void testShouldBeCaseInsentive() throws UsersRepositoryException {
+ void testShouldBeCaseInsentive(TestSystem testSystem) throws UsersRepositoryException {
String password = "password2";
- usersRepository.addUser(user1, password);
+ testee().addUser(testSystem.user1, password);
- assertThat(usersRepository.test(user1CaseVariation, password))
+ assertThat(testee().test(testSystem.user1CaseVariation, password))
.isTrue();
}
@Test
- void addUserShouldAddAUserWhenNotEmptyRepository() throws UsersRepositoryException {
+ void addUserShouldAddAUserWhenNotEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(user2, "password2");
+ testee().addUser(testSystem.user2, "password2");
//When
- usersRepository.addUser(user3, "password3");
+ testee().addUser(testSystem.user3, "password3");
//Then
- assertThat(usersRepository.contains(user3)).isTrue();
+ assertThat(testee().contains(testSystem.user3)).isTrue();
}
@Test
- void addUserShouldThrowWhenSameUsernameWithDifferentCase() throws UsersRepositoryException {
+ void addUserShouldThrowWhenSameUsernameWithDifferentCase(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(login("myUsername"), "password");
+ testee().addUser(testSystem.toUsername("myUsername"), "password");
//When
- assertThatThrownBy(() -> usersRepository.addUser(login("MyUsername"), "password"))
+ assertThatThrownBy(() -> testee().addUser(testSystem.toUsername("MyUsername"), "password"))
.isInstanceOf(AlreadyExistInUsersRepositoryException.class);
}
@Test
- void addUserShouldThrowWhenUserAlreadyPresentInRepository() throws UsersRepositoryException {
+ void addUserShouldThrowWhenUserAlreadyPresentInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(user1, "password");
+ testee().addUser(testSystem.user1, "password");
//When
- assertThatThrownBy(() -> usersRepository.addUser(user1, "password2"))
+ assertThatThrownBy(() -> testee().addUser(testSystem.user1, "password2"))
.isInstanceOf(AlreadyExistInUsersRepositoryException.class);
}
@Test
- void getUserByNameShouldReturnAUserWhenContainedInRepository() throws UsersRepositoryException {
+ void getUserByNameShouldReturnAUserWhenContainedInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(user1, "password");
+ testee().addUser(testSystem.user1, "password");
//When
- User actual = usersRepository.getUserByName(user1);
+ User actual = testee().getUserByName(testSystem.user1);
//Then
assertThat(actual).isNotNull();
- assertThat(actual.getUserName()).isEqualTo(user1);
+ assertThat(actual.getUserName()).isEqualTo(testSystem.user1);
}
@Test
- void getUserByNameShouldReturnUserWhenDifferentCase() throws UsersRepositoryException {
+ void getUserByNameShouldReturnUserWhenDifferentCase(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(login("username"), "password");
+ testee().addUser(testSystem.toUsername("username"), "password");
//When
- User actual = usersRepository.getUserByName(login("uSERNAMe"));
+ User actual = testee().getUserByName(testSystem.toUsername("uSERNAMe"));
//Then
assertThat(actual).isNotNull();
- assertThat(actual.getUserName()).isEqualTo(user1);
+ assertThat(actual.getUserName()).isEqualTo(testSystem.user1);
}
@Test
- void testShouldReturnTrueWhenAUserHasACorrectPassword() throws UsersRepositoryException {
+ void testShouldReturnTrueWhenAUserHasACorrectPassword(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(user1, "password");
+ testee().addUser(testSystem.user1, "password");
//When
- boolean actual = usersRepository.test(user1, "password");
+ boolean actual = testee().test(testSystem.user1, "password");
//Then
assertThat(actual).isTrue();
}
@Test
- void testShouldReturnTrueWhenAUserHasACorrectPasswordAndOtherCaseInDomain() throws Exception {
- usersRepository.setEnableVirtualHosting(true);
+ void testShouldReturnTrueWhenAUserHasACorrectPasswordAndOtherCaseInDomain(TestSystem testSystem) throws Exception {
+ testee().setEnableVirtualHosting(true);
- domainList.addDomain(Domain.of("jAmEs.oRg"));
+ testSystem.domainList.addDomain(Domain.of("jAmEs.oRg"));
String username = "myuser";
String password = "password";
- usersRepository.addUser(Username.of(username + "@jAmEs.oRg"), password);
+ testee().addUser(Username.of(username + "@jAmEs.oRg"), password);
- boolean actual = usersRepository.test(Username.of(username + "@james.org"), password);
+ boolean actual = testee().test(Username.of(username + "@james.org"), password);
assertThat(actual).isTrue();
}
@Test
- void testShouldReturnFalseWhenAUserHasAnIncorrectPassword() throws UsersRepositoryException {
+ void testShouldReturnFalseWhenAUserHasAnIncorrectPassword(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(user1, "password");
+ testee().addUser(testSystem.user1, "password");
//When
- boolean actual = usersRepository.test(user1, "password2");
+ boolean actual = testee().test(testSystem.user1, "password2");
//Then
assertThat(actual).isFalse();
}
@Test
- void testShouldReturnFalseWhenAUserHasAnIncorrectCasePassword() throws UsersRepositoryException {
+ void testShouldReturnFalseWhenAUserHasAnIncorrectCasePassword(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(user1, "password");
+ testee().addUser(testSystem.user1, "password");
//When
- boolean actual = usersRepository.test(user1, "Password");
+ boolean actual = testee().test(testSystem.user1, "Password");
//Then
assertThat(actual).isFalse();
}
@Test
- void testShouldReturnFalseWhenAUserIsNotInRepository() throws UsersRepositoryException {
+ void testShouldReturnFalseWhenAUserIsNotInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(login("username"), "password");
+ testee().addUser(testSystem.toUsername("username"), "password");
//When
- boolean actual = usersRepository.test(login("username2"), "password");
+ boolean actual = testee().test(testSystem.toUsername("username2"), "password");
//Then
assertThat(actual).isFalse();
}
@Test
- void testShouldReturnTrueWhenAUserHasAnIncorrectCaseName() throws UsersRepositoryException {
+ void testShouldReturnTrueWhenAUserHasAnIncorrectCaseName(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(login("username"), "password");
+ testee().addUser(testSystem.toUsername("username"), "password");
//When
- boolean actual = usersRepository.test(login("userName"), "password");
+ boolean actual = testee().test(testSystem.toUsername("userName"), "password");
//Then
assertThat(actual).isTrue();
}
@Test
- void testShouldReturnFalseWhenEmptyRepository() throws UsersRepositoryException {
+ void testShouldReturnFalseWhenEmptyRepository(TestSystem testSystem) throws UsersRepositoryException {
//When
- boolean actual = usersRepository.test(user1, "password");
+ boolean actual = testee().test(testSystem.user1, "password");
//Then
assertThat(actual).isFalse();
}
@Test
- void testShouldReturnFalseWhenAUserIsRemovedFromRepository() throws UsersRepositoryException {
+ void testShouldReturnFalseWhenAUserIsRemovedFromRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(user1, "password");
- usersRepository.removeUser(user1);
+ testee().addUser(testSystem.user1, "password");
+ testee().removeUser(testSystem.user1);
//When
- boolean actual = usersRepository.test(user1, "password");
+ boolean actual = testee().test(testSystem.user1, "password");
//Then
assertThat(actual).isFalse();
}
@Test
- void removeUserShouldRemoveAUserWhenPresentInRepository() throws UsersRepositoryException {
+ void removeUserShouldRemoveAUserWhenPresentInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(user1, "password");
+ testee().addUser(testSystem.user1, "password");
//When
- usersRepository.removeUser(user1);
+ testee().removeUser(testSystem.user1);
//Then
- assertThat(usersRepository.contains(user1)).isFalse();
+ assertThat(testee().contains(testSystem.user1)).isFalse();
}
@Test
- void removeUserShouldThrowWhenUserNotInRepository() {
+ void removeUserShouldThrowWhenUserNotInRepository(TestSystem testSystem) {
//When
- assertThatThrownBy(() -> usersRepository.removeUser(user1))
+ assertThatThrownBy(() -> testee().removeUser(testSystem.user1))
.isInstanceOf(UsersRepositoryException.class);
}
@Test
- void updateUserShouldAllowToAuthenticateWithNewPassword() throws UsersRepositoryException {
+ void updateUserShouldAllowToAuthenticateWithNewPassword(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(user1, "password");
- User user = usersRepository.getUserByName(user1);
+ testee().addUser(testSystem.user1, "password");
+ User user = testee().getUserByName(testSystem.user1);
user.setPassword("newpass");
//When
- usersRepository.updateUser(user);
+ testee().updateUser(user);
//Then
- assertThat(usersRepository.test(user1, "newpass")).isTrue();
+ assertThat(testee().test(testSystem.user1, "newpass")).isTrue();
}
@Test
- void updateUserShouldNotAllowToAuthenticateWithOldPassword() throws UsersRepositoryException {
+ void updateUserShouldNotAllowToAuthenticateWithOldPassword(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(user1, "password");
- User user = usersRepository.getUserByName(user1);
+ testee().addUser(testSystem.user1, "password");
+ User user = testee().getUserByName(testSystem.user1);
user.setPassword("newpass");
//When
- usersRepository.updateUser(user);
+ testee().updateUser(user);
//Then
- assertThat(usersRepository.test(user1, "password")).isFalse();
+ assertThat(testee().test(testSystem.user1, "password")).isFalse();
}
@Test
- void updateUserShouldThrowWhenAUserIsNoMoreInRepository() throws UsersRepositoryException {
+ void updateUserShouldThrowWhenAUserIsNoMoreInRepository(TestSystem testSystem) throws UsersRepositoryException {
//Given
- usersRepository.addUser(user1, "password");
- User user = usersRepository.getUserByName(user1);
- usersRepository.removeUser(user1);
+ testee().addUser(testSystem.user1, "password");
+ User user = testee().getUserByName(testSystem.user1);
+ testee().removeUser(testSystem.user1);
//When
- assertThatThrownBy(() -> usersRepository.updateUser(user))
+ assertThatThrownBy(() -> testee().updateUser(user))
.isInstanceOf(UsersRepositoryException.class);
}
@Test
void virtualHostedUsersRepositoryShouldUseFullMailAddressAsUsername() throws Exception {
- usersRepository.setEnableVirtualHosting(true);
+ testee().setEnableVirtualHosting(true);
// Some implementations do not support changing virtual hosting value
- Assumptions.assumeTrue(usersRepository.supportVirtualHosting());
+ Assumptions.assumeTrue(testee().supportVirtualHosting());
- assertThat(usersRepository.getUsername(new MailAddress("local@domain"))).isEqualTo(Username.of("local@domain"));
+ assertThat(testee().getUsername(new MailAddress("local@domain"))).isEqualTo(Username.of("local@domain"));
}
@Test
void nonVirtualHostedUsersRepositoryShouldUseLocalPartAsUsername() throws Exception {
- usersRepository.setEnableVirtualHosting(false);
+ testee().setEnableVirtualHosting(false);
// Some implementations do not support changing virtual hosting value
- Assumptions.assumeFalse(usersRepository.supportVirtualHosting());
+ Assumptions.assumeFalse(testee().supportVirtualHosting());
- assertThat(usersRepository.getUsername(new MailAddress("local@domain"))).isEqualTo(Username.of("local"));
+ assertThat(testee().getUsername(new MailAddress("local@domain"))).isEqualTo(Username.of("local"));
}
@Test
- void isAdministratorShouldReturnFalseWhenNotConfigured() throws Exception {
- usersRepository.setAdministratorId(Optional.empty());
+ void isAdministratorShouldReturnFalseWhenNotConfigured(TestSystem testSystem) throws Exception {
+ testee().setAdministratorId(Optional.empty());
- assertThat(usersRepository.isAdministrator(admin)).isFalse();
+ assertThat(testee().isAdministrator(testSystem.admin)).isFalse();
}
@Test
- void isAdministratorShouldReturnTrueWhenConfiguredAndUserIsAdmin() throws Exception {
- usersRepository.setAdministratorId(Optional.of(admin));
+ void isAdministratorShouldReturnTrueWhenConfiguredAndUserIsAdmin(TestSystem testSystem) throws Exception {
+ testee().setAdministratorId(Optional.of(testSystem.admin));
- assertThat(usersRepository.isAdministrator(admin)).isTrue();
+ assertThat(testee().isAdministrator(testSystem.admin)).isTrue();
}
@Test
- void isAdministratorShouldReturnFalseWhenConfiguredAndUserIsNotAdmin() throws Exception {
- usersRepository.setAdministratorId(Optional.of(admin));
+ void isAdministratorShouldReturnFalseWhenConfiguredAndUserIsNotAdmin(TestSystem testSystem) throws Exception {
+ testee().setAdministratorId(Optional.of(testSystem.admin));
- assertThat(usersRepository.isAdministrator(user1)).isFalse();
+ assertThat(testee().isAdministrator(testSystem.user1)).isFalse();
}
@Test
void getMailAddressForShouldBeIdentityWhenVirtualHosting() throws Exception {
- usersRepository.setEnableVirtualHosting(true);
+ testee().setEnableVirtualHosting(true);
// Some implementations do not support changing virtual hosting value
- Assumptions.assumeTrue(usersRepository.supportVirtualHosting());
+ Assumptions.assumeTrue(testee().supportVirtualHosting());
String username = "user@domain";
- assertThat(usersRepository.getMailAddressFor(Username.of(username)))
+ assertThat(testee().getMailAddressFor(Username.of(username)))
.isEqualTo(username);
}
@Test
- void getMailAddressForShouldAppendDefaultDomainWhenNoVirtualHosting() throws Exception {
- usersRepository.setEnableVirtualHosting(false);
+ void getMailAddressForShouldAppendDefaultDomainWhenNoVirtualHosting(TestSystem testSystem) throws Exception {
+ testee().setEnableVirtualHosting(false);
// Some implementations do not support changing virtual hosting value
- Assumptions.assumeFalse(usersRepository.supportVirtualHosting());
+ Assumptions.assumeFalse(testee().supportVirtualHosting());
String username = "user";
- assertThat(usersRepository.getMailAddressFor(Username.of(username)))
- .isEqualTo(new MailAddress(username, domainList.getDefaultDomain()));
+ assertThat(testee().getMailAddressFor(Username.of(username)))
+ .isEqualTo(new MailAddress(username, testSystem.domainList.getDefaultDomain()));
}
@ParameterizedTest
@MethodSource("illegalCharacters")
void assertValidShouldThrowWhenUsernameLocalPartWithIllegalCharacter(String illegalCharacter) {
- assertThatThrownBy(() -> usersRepository.assertValid(Username.of("a" + illegalCharacter + "a")))
+ assertThatThrownBy(() -> testee().assertValid(Username.of("a" + illegalCharacter + "a")))
.isInstanceOf(InvalidUsernameException.class);
}
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 6cd6c4f..54ddc17 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
@@ -31,30 +31,36 @@ 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.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() throws Exception {
- super.setUp();
+ void setUp(TestSystem testSystem) {
+ memoryUsersRepository = MemoryUsersRepository.withVirtualHosting(testSystem.getDomainList());
}
-
+
@Override
- protected AbstractUsersRepository getUsersRepository() {
- return MemoryUsersRepository.withVirtualHosting(domainList);
+ protected AbstractUsersRepository testee() {
+ return memoryUsersRepository;
}
@Test
- void assertValidShouldThrowWhenDomainPartAndNoVirtualHosting() {
- MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withoutVirtualHosting(domainList);
+ void assertValidShouldThrowWhenDomainPartAndNoVirtualHosting(TestSystem testSystem) {
+ MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withoutVirtualHosting(testSystem.getDomainList());
assertThatThrownBy(() -> memoryUsersRepository.assertValid(Username.of("user@domain.tld")))
.isInstanceOf(UsersRepositoryException.class);
}
@Test
- void assertValidShouldThrowWhenNoDomainPartAndVirtualHosting() {
- MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withVirtualHosting(domainList);
+ void assertValidShouldThrowWhenNoDomainPartAndVirtualHosting(TestSystem testSystem) {
+ MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withVirtualHosting(testSystem.getDomainList());
assertThatThrownBy(() -> memoryUsersRepository.assertValid(Username.of("user")))
.isInstanceOf(UsersRepositoryException.class);
@@ -90,8 +96,8 @@ class MemoryUsersRepositoryTest extends AbstractUsersRepositoryTest {
}
@Test
- void assertValidShouldNotThrowWhenNoDomainPartAndNoVirtualHosting() {
- MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withoutVirtualHosting(domainList);
+ void assertValidShouldNotThrowWhenNoDomainPartAndNoVirtualHosting(TestSystem testSystem) {
+ MemoryUsersRepository memoryUsersRepository = MemoryUsersRepository.withoutVirtualHosting(testSystem.getDomainList());
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