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/14 02:09:46 UTC
[james-project] 29/32: [Refactoring] JAMES-2950 Move UsernameTest
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 47ed14103f487e5da07ddc0a63c711aa43b84be9
Author: Rene Cordier <rc...@linagora.com>
AuthorDate: Thu Oct 31 15:28:10 2019 +0700
[Refactoring] JAMES-2950 Move UsernameTest to JUnit 5
---
.../java/org/apache/james/core/UsernameTest.java | 73 +++++++++++-----------
1 file changed, 36 insertions(+), 37 deletions(-)
diff --git a/core/src/test/java/org/apache/james/core/UsernameTest.java b/core/src/test/java/org/apache/james/core/UsernameTest.java
index 9a8a3a2..8fe63d1 100644
--- a/core/src/test/java/org/apache/james/core/UsernameTest.java
+++ b/core/src/test/java/org/apache/james/core/UsernameTest.java
@@ -25,220 +25,219 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Optional;
import org.apache.commons.lang3.StringUtils;
+import org.junit.jupiter.api.Test;
-import org.junit.Test;
-
-public class UsernameTest {
+class UsernameTest {
@Test
- public void fromShouldThrowOnEmptyLocalPart() {
+ void fromShouldThrowOnEmptyLocalPart() {
assertThatThrownBy(() -> Username.from("", Optional.empty()))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromShouldThrowOnNullDomainPart() {
+ void fromShouldThrowOnNullDomainPart() {
assertThatThrownBy(() -> Username.from(null, Optional.empty()))
.isInstanceOf(NullPointerException.class);
}
@Test
- public void fromShouldThrowOnLocalPartWithDomainDelimiter() {
+ void fromShouldThrowOnLocalPartWithDomainDelimiter() {
assertThatThrownBy(() -> Username.from("aa@bb", Optional.empty()))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromShouldThrowOnEmptyDomain() {
+ void fromShouldThrowOnEmptyDomain() {
assertThatThrownBy(() -> Username.from("aa", Optional.of("")))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromShouldThrowWhenDomainContainsDomainDelimiter() {
+ void fromShouldThrowWhenDomainContainsDomainDelimiter() {
assertThatThrownBy(() -> Username.from("aa", Optional.of("bb@cc")))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromLocalPartWithDomainStringVersionShouldThrowOnNullLocalPart() {
+ void fromLocalPartWithDomainStringVersionShouldThrowOnNullLocalPart() {
assertThatThrownBy(() -> Username.fromLocalPartWithDomain(null, "domain"))
.isInstanceOf(NullPointerException.class);
}
@Test
- public void fromLocalPartWithDomainStringVersionShouldThrowOnEmptyLocalPart() {
+ void fromLocalPartWithDomainStringVersionShouldThrowOnEmptyLocalPart() {
assertThatThrownBy(() -> Username.fromLocalPartWithDomain("", "domain"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromLocalPartWithDomainStringVersionShouldThrowOnLocalPartThatContainsDomainDelimiter() {
+ void fromLocalPartWithDomainStringVersionShouldThrowOnLocalPartThatContainsDomainDelimiter() {
assertThatThrownBy(() -> Username.fromLocalPartWithDomain("aa@bb", "domain"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromLocalPartWithDomainStringVersionShouldThrowOnNullDomainPart() {
+ void fromLocalPartWithDomainStringVersionShouldThrowOnNullDomainPart() {
String domain = null;
assertThatThrownBy(() -> Username.fromLocalPartWithDomain("local", domain))
.isInstanceOf(NullPointerException.class);
}
@Test
- public void fromLocalPartWithDomainStringVersionShouldThrowOnEmptyDomainPart() {
+ void fromLocalPartWithDomainStringVersionShouldThrowOnEmptyDomainPart() {
assertThatThrownBy(() -> Username.fromLocalPartWithDomain("local", ""))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromLocalPartWithDomainStringVersionShouldThrowOnDomainPartThatContainsDomainDelimiter() {
+ void fromLocalPartWithDomainStringVersionShouldThrowOnDomainPartThatContainsDomainDelimiter() {
assertThatThrownBy(() -> Username.fromLocalPartWithDomain("local", "aa@bb"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromLocalPartWithoutDomainShouldThrowOnEmpty() {
+ void fromLocalPartWithoutDomainShouldThrowOnEmpty() {
assertThatThrownBy(() -> Username.fromLocalPartWithoutDomain(""))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromLocalPartWithoutDomainShouldThrowOnNull() {
+ void fromLocalPartWithoutDomainShouldThrowOnNull() {
assertThatThrownBy(() -> Username.fromLocalPartWithoutDomain(null))
.isInstanceOf(NullPointerException.class);
}
@Test
- public void fromLocalPartWithoutDomainShouldThrowOnUsernameThatContainsDomainDelimiter() {
+ void fromLocalPartWithoutDomainShouldThrowOnUsernameThatContainsDomainDelimiter() {
assertThatThrownBy(() -> Username.fromLocalPartWithoutDomain("aa@bb"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromUsernameShouldThrowOnNull() {
+ void fromUsernameShouldThrowOnNull() {
assertThatThrownBy(() -> Username.of(null))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromUsernameShouldThrowOnEmpty() {
+ void fromUsernameShouldThrowOnEmpty() {
assertThatThrownBy(() -> Username.of(""))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromUsernameShouldAllow255LongUsername() {
+ void fromUsernameShouldAllow255LongUsername() {
String tail = "@a";
assertThat(Username.of(StringUtils.repeat('j', 255 - tail.length()) + tail).asString())
.hasSize(255);
}
@Test
- public void fromUsernameShouldThrowWhenTooLong() {
+ void fromUsernameShouldThrowWhenTooLong() {
String tail = "@a";
assertThatThrownBy(() -> Username.of(StringUtils.repeat('j', 255 - tail.length() + 1) + tail))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromUsernameShouldThrowWhenMultipleDomainDelimiter() {
+ void fromUsernameShouldThrowWhenMultipleDomainDelimiter() {
assertThatThrownBy(() -> Username.of("aa@aa@aa"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromUsernameShouldThrowWhenEndsWithDomainDelimiter() {
+ void fromUsernameShouldThrowWhenEndsWithDomainDelimiter() {
assertThatThrownBy(() -> Username.of("aa@"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromUsernameShouldThrowWhenStartsWithDomainDelimiter() {
+ void fromUsernameShouldThrowWhenStartsWithDomainDelimiter() {
assertThatThrownBy(() -> Username.of("@aa"))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
- public void fromUsernameShouldParseUsernameWithDomain() {
+ void fromUsernameShouldParseUsernameWithDomain() {
assertThat(Username.of("aa@bb"))
.isEqualTo(Username.from("aa", Optional.of("bb")));
}
@Test
- public void fromUsernameShouldParseUsernameWithoutDomain() {
+ void fromUsernameShouldParseUsernameWithoutDomain() {
assertThat(Username.of("aa"))
.isEqualTo(Username.from("aa", Optional.empty()));
}
@Test
- public void fromLocalPartWithDomainShouldReturnAValidUser() {
+ void fromLocalPartWithDomainShouldReturnAValidUser() {
assertThat(Username.fromLocalPartWithDomain("aa", "bb"))
.isEqualTo(Username.from("aa", Optional.of("bb")));
}
@Test
- public void fromLocalPartWithoutDomainShouldReturnAValidUser() {
+ void fromLocalPartWithoutDomainShouldReturnAValidUser() {
assertThat(Username.fromLocalPartWithoutDomain("aa"))
.isEqualTo(Username.from("aa", Optional.empty()));
}
@Test
- public void hasDomainPartShouldReturnFalseWhenNoDomain() {
+ void hasDomainPartShouldReturnFalseWhenNoDomain() {
assertThat(Username.fromLocalPartWithoutDomain("aa").hasDomainPart())
.isFalse();
}
@Test
- public void hasDomainPartShouldReturnTrueWhenHasADomain() {
+ void hasDomainPartShouldReturnTrueWhenHasADomain() {
assertThat(Username.fromLocalPartWithDomain("aa", "domain").hasDomainPart())
.isTrue();
}
@Test
- public void withDefaultDomainShouldAppendDefaultDomainWhenNone() {
+ void withDefaultDomainShouldAppendDefaultDomainWhenNone() {
assertThat(Username.of("user")
.withDefaultDomain(Domain.LOCALHOST))
.isEqualTo(Username.fromLocalPartWithDomain("user", Domain.LOCALHOST));
}
@Test
- public void withDefaultDomainShouldNotAppendDefaultDomainWhenDomainIsPresent() {
+ void withDefaultDomainShouldNotAppendDefaultDomainWhenDomainIsPresent() {
assertThat(Username.of("user@domain")
.withDefaultDomain(Domain.LOCALHOST))
.isEqualTo(Username.of("user@domain"));
}
@Test
- public void withDefaultDomainShouldNotThrowUponEmptyDomain() {
+ void withDefaultDomainShouldNotThrowUponEmptyDomain() {
assertThat(Username.of("user")
.withDefaultDomain(Optional.empty()))
.isEqualTo(Username.of("user"));
}
@Test
- public void withDefaultDomainShouldNotThrowUponEmptyDomainWhenUsersHadADomain() {
+ void withDefaultDomainShouldNotThrowUponEmptyDomainWhenUsersHadADomain() {
assertThat(Username.of("user@domain")
.withDefaultDomain(Optional.empty()))
.isEqualTo(Username.of("user@domain"));
}
@Test
- public void withDefaultDomainFromUserShouldPreserveUserWhenAlreadyHasADomain() {
+ void withDefaultDomainFromUserShouldPreserveUserWhenAlreadyHasADomain() {
assertThat(Username.of("user@domain")
.withDefaultDomainFromUser(Username.of("bob@tld")))
.isEqualTo(Username.of("user@domain"));
}
@Test
- public void withDefaultDomainFromUserShouldAppendOtherUserDomainWhenNone() {
+ void withDefaultDomainFromUserShouldAppendOtherUserDomainWhenNone() {
assertThat(Username.of("user")
.withDefaultDomainFromUser(Username.of("bob@tld")))
.isEqualTo(Username.of("user@tld"));
}
@Test
- public void withDefaultDomainFromUserShouldNotThrowUponNoDomain() {
+ void withDefaultDomainFromUserShouldNotThrowUponNoDomain() {
assertThat(Username.of("user")
.withDefaultDomainFromUser(Username.of("bob")))
.isEqualTo(Username.of("user"));
---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscribe@james.apache.org
For additional commands, e-mail: server-dev-help@james.apache.org