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 ma...@apache.org on 2018/04/24 12:50:46 UTC
[17/27] james-project git commit: JAMES-2366 remove MappingImpl and
simulate an Algebric Type with factories and functions
JAMES-2366 remove MappingImpl and simulate an Algebric Type with factories and functions
Project: http://git-wip-us.apache.org/repos/asf/james-project/repo
Commit: http://git-wip-us.apache.org/repos/asf/james-project/commit/1ba2bfc3
Tree: http://git-wip-us.apache.org/repos/asf/james-project/tree/1ba2bfc3
Diff: http://git-wip-us.apache.org/repos/asf/james-project/diff/1ba2bfc3
Branch: refs/heads/master
Commit: 1ba2bfc3b353bf22498eed22d4c64df6482545e2
Parents: 4683d76
Author: Matthieu Baechler <ma...@apache.org>
Authored: Wed Apr 18 11:08:01 2018 +0200
Committer: Matthieu Baechler <ma...@apache.org>
Committed: Tue Apr 24 14:45:26 2018 +0200
----------------------------------------------------------------------
.../james/cli/DataCommandsIntegrationTest.java | 6 +-
.../java/org/apache/james/rrt/lib/Mapping.java | 250 ++++++++++++++-----
.../org/apache/james/rrt/lib/MappingTest.java | 166 ++++++++++++
.../rrt/file/XMLRecipientRewriteTableTest.java | 8 +-
.../rrt/lib/AbstractRecipientRewriteTable.java | 37 ++-
.../org/apache/james/rrt/lib/MappingImpl.java | 164 ------------
.../org/apache/james/rrt/lib/MappingsImpl.java | 4 +-
.../lib/RecipientRewriteTableManagement.java | 4 +-
.../lib/AbstractRecipientRewriteTableTest.java | 92 +++----
.../apache/james/rrt/lib/MappingImplTest.java | 221 ----------------
.../apache/james/rrt/lib/MappingsImplTest.java | 102 ++++----
11 files changed, 484 insertions(+), 570 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/james-project/blob/1ba2bfc3/server/container/cli-integration/src/test/java/org/apache/james/cli/DataCommandsIntegrationTest.java
----------------------------------------------------------------------
diff --git a/server/container/cli-integration/src/test/java/org/apache/james/cli/DataCommandsIntegrationTest.java b/server/container/cli-integration/src/test/java/org/apache/james/cli/DataCommandsIntegrationTest.java
index 03c29c2..b6579d5 100644
--- a/server/container/cli-integration/src/test/java/org/apache/james/cli/DataCommandsIntegrationTest.java
+++ b/server/container/cli-integration/src/test/java/org/apache/james/cli/DataCommandsIntegrationTest.java
@@ -29,7 +29,7 @@ import org.apache.james.MemoryJmapTestRule;
import org.apache.james.cli.util.OutputCapture;
import org.apache.james.mailbox.store.search.ListeningMessageSearchIndex;
import org.apache.james.modules.server.JMXServerModule;
-import org.apache.james.rrt.lib.MappingImpl;
+import org.apache.james.rrt.lib.Mapping;
import org.apache.james.rrt.lib.Mappings;
import org.apache.james.rrt.lib.MappingsImpl;
import org.apache.james.utils.DataProbeImpl;
@@ -141,7 +141,7 @@ public class DataCommandsIntegrationTest {
new AbstractMap.SimpleEntry<String, Mappings>(
MAIL_ADDRESS,
MappingsImpl.builder()
- .add(MappingImpl.address(redirectionAddress))
+ .add(Mapping.address(redirectionAddress))
.build()));
}
@@ -190,7 +190,7 @@ public class DataCommandsIntegrationTest {
new AbstractMap.SimpleEntry<String, Mappings>(
MAIL_ADDRESS,
MappingsImpl.builder()
- .add(MappingImpl.regex(regex))
+ .add(Mapping.regex(regex))
.build()));
}
http://git-wip-us.apache.org/repos/asf/james-project/blob/1ba2bfc3/server/data/data-api/src/main/java/org/apache/james/rrt/lib/Mapping.java
----------------------------------------------------------------------
diff --git a/server/data/data-api/src/main/java/org/apache/james/rrt/lib/Mapping.java b/server/data/data-api/src/main/java/org/apache/james/rrt/lib/Mapping.java
index 751000d..e32dc1e 100644
--- a/server/data/data-api/src/main/java/org/apache/james/rrt/lib/Mapping.java
+++ b/server/data/data-api/src/main/java/org/apache/james/rrt/lib/Mapping.java
@@ -26,16 +26,82 @@ import java.util.stream.Stream;
import javax.mail.internet.AddressException;
-import org.apache.commons.lang3.NotImplementedException;
import org.apache.james.core.Domain;
import org.apache.james.core.MailAddress;
import org.apache.james.core.User;
import org.apache.james.rrt.api.RecipientRewriteTableException;
+import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
public interface Mapping {
+ static Mapping of(String mapping) {
+ Type type = Mapping.detectType(mapping);
+ return of(type, type.withoutPrefix(mapping));
+ }
+
+ static Mapping of(Type type, String mapping) {
+ UserRewritter.MappingUserRewriter rewriter = selectRewriter(type);
+ IdentityMappingPolicy identityMappingPolicy = selectIdentityPolicy(type);
+ return new Impl(type, mapping, rewriter.generateUserRewriter(mapping), identityMappingPolicy);
+ }
+
+ static UserRewritter.MappingUserRewriter selectRewriter(Type type) {
+ switch (type) {
+ case Regex:
+ return new UserRewritter.RegexRewriter();
+ case Domain:
+ return new UserRewritter.DomainRewriter();
+ case Error:
+ return new UserRewritter.NoneRewriter();
+ case Forward:
+ case Group:
+ case Address:
+ return new UserRewritter.ReplaceRewriter();
+ }
+ throw new IllegalStateException("unhandle enum type");
+ }
+
+ static IdentityMappingPolicy selectIdentityPolicy(Type type) {
+ switch (type) {
+ case Regex:
+ case Domain:
+ case Error:
+ case Group:
+ case Address:
+ return IdentityMappingPolicy.Throw;
+ case Forward:
+ return IdentityMappingPolicy.ReturnIdentity;
+ }
+ throw new IllegalStateException("unhandle enum type");
+ }
+
+
+ static Mapping address(String mapping) {
+ return of(Type.Address, mapping);
+ }
+
+ static Mapping regex(String mapping) {
+ return of(Type.Regex, mapping);
+ }
+
+ static Mapping error(String mapping) {
+ return of(Type.Error, mapping);
+ }
+
+ static Mapping domain(Domain mapping) {
+ return of(Type.Domain, mapping.asString());
+ }
+
+ static Mapping forward(String mapping) {
+ return of(Type.Forward, mapping);
+ }
+
+ static Mapping group(String mapping) {
+ return of(Type.Group, mapping);
+ }
+
static Type detectType(String input) {
if (input.startsWith(Type.Regex.asPrefix())) {
return Type.Regex;
@@ -55,52 +121,18 @@ public interface Mapping {
return Type.Address;
}
- Optional<MailAddress> asMailAddress();
-
enum Type {
- Regex("regex:", IdentityMappingBehaviour.Throw) {
- @Override
- protected UserRewritter rewriter(String mapping) {
- return new UserRewritter.RegexRewriter().generateUserRewriter(mapping);
- }
- },
- Domain("domain:", IdentityMappingBehaviour.Throw) {
- @Override
- protected UserRewritter rewriter(String mapping) {
- return new UserRewritter.DomainRewriter().generateUserRewriter(mapping);
- }
- },
- Error("error:", IdentityMappingBehaviour.Throw) {
- @Override
- protected UserRewritter rewriter(String mapping) {
- return new UserRewritter.NoneRewriter().generateUserRewriter(mapping);
- }
- },
- Forward("forward:", IdentityMappingBehaviour.ReturnIdentity) {
- @Override
- protected UserRewritter rewriter(String mapping) {
- return new UserRewritter.ReplaceRewriter().generateUserRewriter(mapping);
- }
- },
- Group("group:", IdentityMappingBehaviour.Throw) {
- @Override
- protected UserRewritter rewriter(String mapping) {
- return new UserRewritter.ReplaceRewriter().generateUserRewriter(mapping);
- }
- },
- Address("", IdentityMappingBehaviour.Throw) {
- @Override
- protected UserRewritter rewriter(String mapping) {
- return new UserRewritter.ReplaceRewriter().generateUserRewriter(mapping);
- }
- };
+ Regex("regex:"),
+ Domain("domain:"),
+ Error("error:"),
+ Forward("forward:"),
+ Group("group:"),
+ Address("");
private final String asPrefix;
- private final IdentityMappingBehaviour identityMappingBehaviour;
- Type(String asPrefix, IdentityMappingBehaviour identityMappingBehaviour) {
+ Type(String asPrefix) {
this.asPrefix = asPrefix;
- this.identityMappingBehaviour = identityMappingBehaviour;
}
public String asPrefix() {
@@ -120,28 +152,130 @@ public interface Mapping {
|| mapping.startsWith(Group.asPrefix());
}
- public IdentityMappingBehaviour getIdentityMappingBehaviour() {
- return identityMappingBehaviour;
- }
+ }
- protected abstract UserRewritter rewriter(String mapping);
+ enum IdentityMappingPolicy {
+ Throw {
+ @Override
+ public Stream<Mapping> handleIdentity(Stream<Mapping> mapping) {
+ throw new SkipMappingProcessingException();
+ }
+ },
+ ReturnIdentity {
+ @Override
+ public Stream<Mapping> handleIdentity(Stream<Mapping> mapping) {
+ return mapping;
+ }
+ };
+ public abstract Stream<Mapping> handleIdentity(Stream<Mapping> mapping);
}
- enum IdentityMappingBehaviour {
- Throw,
- ReturnIdentity;
-
- public Stream<Mapping> handleIdentity(Stream<Mapping> mapping) {
- switch (this) {
- case Throw:
- throw new SkipMappingProcessingException();
- case ReturnIdentity:
- return mapping;
- default:
- throw new NotImplementedException("Unknown IdentityMappingBehaviour : " + this);
+ Optional<MailAddress> asMailAddress();
+
+ Stream<Mapping> handleIdentity(Stream<Mapping> nonRecursiveResult);
+
+ class Impl implements Mapping {
+
+ private final Type type;
+ private final String mapping;
+ private final UserRewritter rewriter;
+ private final IdentityMappingPolicy identityMappingPolicy;
+
+ private Impl(Type type, String mapping, UserRewritter rewriter, IdentityMappingPolicy identityMappingBehaviour) {
+ Preconditions.checkNotNull(type);
+ Preconditions.checkNotNull(mapping);
+ this.type = type;
+ this.mapping = mapping;
+ this.rewriter = rewriter;
+ this.identityMappingPolicy = identityMappingBehaviour;
+ }
+
+ @Override
+ public String asString() {
+ return type.asPrefix() + mapping;
+ }
+
+ @Override
+ public boolean hasDomain() {
+ return mapping.contains("@");
+ }
+
+ @Override
+ public Mapping appendDomainIfNone(Supplier<Domain> domain) {
+ Preconditions.checkNotNull(domain);
+ if (hasDomain()) {
+ return this;
}
+ return appendDomain(domain.get());
}
+
+ @Override
+ public Mapping appendDomainFromThrowingSupplierIfNone(ThrowingDomainSupplier supplier) throws RecipientRewriteTableException {
+ Preconditions.checkNotNull(supplier);
+ if (hasDomain()) {
+ return this;
+ }
+ return appendDomain(supplier.get());
+ }
+
+ private Mapping appendDomain(Domain domain) {
+ return of(type, mapping + "@" + domain.asString());
+ }
+
+ @Override
+ public Type getType() {
+ return type;
+ }
+
+ @Override
+ public String getErrorMessage() {
+ Preconditions.checkState(getType() == Type.Error);
+ return mapping;
+ }
+
+ @Override
+ public Optional<MailAddress> asMailAddress() {
+ if (type != Type.Address && type != Type.Forward && type != Type.Group) {
+ return Optional.empty();
+ }
+ try {
+ return Optional.of(new MailAddress(mapping));
+ } catch (AddressException e) {
+ return Optional.empty();
+ }
+ }
+
+ @Override
+ public Optional<User> rewriteUser(User user) throws AddressException {
+ return rewriter.rewrite(user);
+ }
+
+ @Override
+ public Stream<Mapping> handleIdentity(Stream<Mapping> nonRecursiveResult) {
+ return identityMappingPolicy.handleIdentity(nonRecursiveResult);
+ }
+
+ @Override
+ public final boolean equals(Object other) {
+ if (other instanceof Impl) {
+ Impl otherMapping = (Impl) other;
+ return Objects.equal(type, otherMapping.type)
+ && Objects.equal(mapping, otherMapping.mapping);
+ }
+ return false;
+ }
+
+ @Override
+ public final int hashCode() {
+ return Objects.hashCode(type, mapping);
+ }
+
+ @Override
+ public String toString() {
+ return "Mapping{type=" + type + " mapping=" + mapping + "}";
+ }
+
}
Type getType();
http://git-wip-us.apache.org/repos/asf/james-project/blob/1ba2bfc3/server/data/data-api/src/test/java/org/apache/james/rrt/lib/MappingTest.java
----------------------------------------------------------------------
diff --git a/server/data/data-api/src/test/java/org/apache/james/rrt/lib/MappingTest.java b/server/data/data-api/src/test/java/org/apache/james/rrt/lib/MappingTest.java
index 8297fca..d14dd6b 100644
--- a/server/data/data-api/src/test/java/org/apache/james/rrt/lib/MappingTest.java
+++ b/server/data/data-api/src/test/java/org/apache/james/rrt/lib/MappingTest.java
@@ -21,9 +21,13 @@ package org.apache.james.rrt.lib;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import org.apache.james.core.Domain;
+import org.apache.james.core.MailAddress;
import org.apache.james.rrt.lib.Mapping.Type;
import org.junit.jupiter.api.Test;
+import nl.jqno.equalsverifier.EqualsVerifier;
+
public class MappingTest {
@Test
@@ -139,4 +143,166 @@ public class MappingTest {
assertThatThrownBy(() -> Type.Forward.withoutPrefix("mapping"))
.isInstanceOf(IllegalArgumentException.class);
}
+
+ @Test
+ public void beanShouldRespectBeanContract() {
+ EqualsVerifier.forClass(Mapping.Impl.class)
+ .verify();
+ }
+
+ @Test
+ public void addressFactoryMethodShouldThrowOnNull() {
+ assertThatThrownBy(() -> Mapping.address(null))
+ .isInstanceOf(NullPointerException.class);
+ }
+
+ @Test
+ public void regexFactoryMethodShouldThrowOnNull() {
+ assertThatThrownBy(() -> Mapping.regex(null))
+ .isInstanceOf(NullPointerException.class);
+ }
+
+ @Test
+ public void domainFactoryMethodShouldThrowOnNull() {
+ assertThatThrownBy(() -> Mapping.domain(null))
+ .isInstanceOf(NullPointerException.class);
+ }
+
+ @Test
+ public void errorFactoryMethodShouldThrowOnNull() {
+ assertThatThrownBy(() -> Mapping.error(null))
+ .isInstanceOf(NullPointerException.class);
+ }
+
+ @Test
+ public void forwardFactoryMethodShouldThrowOnNull() {
+ assertThatThrownBy(() -> Mapping.forward(null))
+ .isInstanceOf(NullPointerException.class);
+ }
+
+ @Test
+ public void groupFactoryMethodShouldThrowOnNull() {
+ assertThatThrownBy(() -> Mapping.group(null))
+ .isInstanceOf(NullPointerException.class);
+ }
+
+ @Test
+ public void hasDomainShouldReturnTrueWhenMappingContainAtMark() {
+ assertThat(Mapping.address("a@b").hasDomain()).isTrue();
+ }
+
+ @Test
+ public void hasDomainShouldReturnFalseWhenMappingIsEmpty() {
+ assertThat(Mapping.address("").hasDomain()).isFalse();
+ }
+
+ @Test
+ public void hasDomainShouldReturnFalseWhenMappingIsBlank() {
+ assertThat(Mapping.address(" ").hasDomain()).isFalse();
+ }
+
+ @Test
+ public void hasDomainShouldReturnFalseWhenMappingDoesntContainAtMark() {
+ assertThat(Mapping.address("abc").hasDomain()).isFalse();
+ }
+
+ @Test
+ public void appendDefaultDomainShouldWorkOnValidDomain() {
+ assertThat(Mapping.address("abc").appendDomainIfNone(() -> Domain.of("domain"))).isEqualTo(Mapping.address("abc@domain"));
+ }
+
+ @Test
+ public void appendDefaultDomainShouldNotAddDomainWhenMappingAlreadyContainsDomains() {
+ assertThat(Mapping.address("abc@d").appendDomainIfNone(() -> Domain.of("domain"))).isEqualTo(Mapping.address("abc@d"));
+ }
+
+ @Test
+ public void appendDomainShouldThrowWhenNullDomain() {
+ assertThatThrownBy(() -> Mapping.address("abc@d").appendDomainIfNone(null)).isInstanceOf(NullPointerException.class);
+ }
+
+ @Test
+ public void getTypeShouldReturnAddressWhenNoPrefix() {
+ assertThat(Mapping.address("abc").getType()).isEqualTo(Mapping.Type.Address);
+ }
+
+ @Test
+ public void getTypeShouldReturnAddressWhenEmpty() {
+ assertThat(Mapping.address("").getType()).isEqualTo(Mapping.Type.Address);
+ }
+
+ @Test
+ public void getTypeShouldReturnRegexWhenRegexPrefix() {
+ assertThat(Mapping.regex("abc").getType()).isEqualTo(Mapping.Type.Regex);
+ }
+
+ @Test
+ public void getTypeShouldReturnErrorWhenErrorPrefix() {
+ assertThat(Mapping.error("abc").getType()).isEqualTo(Mapping.Type.Error);
+ }
+
+ @Test
+ public void getTypeShouldReturnDomainWhenDomainPrefix() {
+ assertThat(Mapping.domain(Domain.of("abc")).getType()).isEqualTo(Mapping.Type.Domain);
+ }
+
+ @Test
+ public void getTypeShouldReturnForwardWhenForwardPrefix() {
+ assertThat(Mapping.forward("abc").getType()).isEqualTo(Mapping.Type.Forward);
+ }
+
+ @Test
+ public void getTypeShouldReturnGroupWhenGroupPrefix() {
+ assertThat(Mapping.group("abc").getType()).isEqualTo(Mapping.Type.Group);
+ }
+
+ @Test
+ public void getErrorMessageShouldThrowWhenMappingIsNotAnError() {
+ assertThatThrownBy(() -> Mapping.domain(Domain.of("toto")).getErrorMessage())
+ .isInstanceOf(IllegalStateException.class);
+ }
+
+ @Test
+ public void getErrorMessageShouldReturnMessageWhenErrorWithMessage() {
+ assertThat(Mapping.error("toto").getErrorMessage()).isEqualTo("toto");
+ }
+
+ @Test
+ public void getErrorMessageShouldReturnWhenErrorWithoutMessage() {
+ assertThat(Mapping.error("").getErrorMessage()).isEqualTo("");
+ }
+
+ @Test
+ public void asMailAddressShouldReturnMappingValueForAddress() throws Exception {
+ assertThat(Mapping.address("value@domain").asMailAddress())
+ .contains(new MailAddress("value@domain"));
+ }
+
+ @Test
+ public void asMailAddressShouldReturnEmptyOnInvalidAddress() {
+ assertThat(Mapping.address("value").asMailAddress())
+ .isEmpty();
+ }
+
+ @Test
+ public void asMailAddressShouldReturnEmptyForError() {
+ assertThat(Mapping.error("value").asMailAddress()).isEmpty();
+ }
+
+ @Test
+ public void asMailAddressShouldReturnEmptyForRegex() {
+ assertThat(Mapping.regex("value").asMailAddress()).isEmpty();
+ }
+
+ @Test
+ public void asMailAddressShouldReturnEmptyForDomain() {
+ assertThat(Mapping.domain(Domain.of("value")).asMailAddress()).isEmpty();
+ }
+
+ @Test
+ public void asMailAddressShouldReturnMappingValueForForward() throws Exception {
+ assertThat(Mapping.forward("value@domain").asMailAddress())
+ .contains(new MailAddress("value@domain"));
+ }
+
}
http://git-wip-us.apache.org/repos/asf/james-project/blob/1ba2bfc3/server/data/data-file/src/test/java/org/apache/james/rrt/file/XMLRecipientRewriteTableTest.java
----------------------------------------------------------------------
diff --git a/server/data/data-file/src/test/java/org/apache/james/rrt/file/XMLRecipientRewriteTableTest.java b/server/data/data-file/src/test/java/org/apache/james/rrt/file/XMLRecipientRewriteTableTest.java
index 9287842..25defc6 100644
--- a/server/data/data-file/src/test/java/org/apache/james/rrt/file/XMLRecipientRewriteTableTest.java
+++ b/server/data/data-file/src/test/java/org/apache/james/rrt/file/XMLRecipientRewriteTableTest.java
@@ -29,7 +29,7 @@ import org.apache.james.rrt.lib.AbstractRecipientRewriteTable;
import org.apache.james.rrt.lib.AbstractRecipientRewriteTableTest;
import org.apache.james.rrt.lib.Mapping;
import org.apache.james.rrt.lib.Mapping.Type;
-import org.apache.james.rrt.lib.MappingImpl;
+import org.apache.james.rrt.lib.Mapping;
import org.apache.james.rrt.lib.Mappings;
import org.apache.james.rrt.lib.MappingsImpl;
import org.junit.After;
@@ -69,7 +69,7 @@ public class XMLRecipientRewriteTableTest extends AbstractRecipientRewriteTableT
@Override
public void addAddressMapping(String user, Domain domain, String address) throws RecipientRewriteTableException {
- addMapping(user, domain, MappingImpl.address(address));
+ addMapping(user, domain, Mapping.address(address));
}
};
}
@@ -85,7 +85,7 @@ public class XMLRecipientRewriteTableTest extends AbstractRecipientRewriteTableT
.orElse(MappingsImpl.empty());
Mappings updatedMappings = MappingsImpl.from(mappings)
- .add(MappingImpl.of(type, mapping))
+ .add(Mapping.of(type, mapping))
.build();
updateConfiguration(user, domain, mappings, updatedMappings);
@@ -95,7 +95,7 @@ public class XMLRecipientRewriteTableTest extends AbstractRecipientRewriteTableT
Mappings oldMappings = Optional.ofNullable(virtualUserTable.getUserDomainMappings(user, domain))
.orElseThrow(() -> new RecipientRewriteTableException("Cannot remove from null mappings"));
- Mappings updatedMappings = oldMappings.remove(MappingImpl.of(type, mapping));
+ Mappings updatedMappings = oldMappings.remove(Mapping.of(type, mapping));
updateConfiguration(user, domain, oldMappings, updatedMappings);
}
http://git-wip-us.apache.org/repos/asf/james-project/blob/1ba2bfc3/server/data/data-library/src/main/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTable.java
----------------------------------------------------------------------
diff --git a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTable.java b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTable.java
index 08e4c5b..4a22f4b 100644
--- a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTable.java
+++ b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTable.java
@@ -127,7 +127,7 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
Function<User, Stream<Mapping>> convertAndRecurseMapping =
Throwing
- .function((User rewrittenUser) -> convertAndRecurseMapping(associatedMapping.getType(), originalUser, rewrittenUser, remainingLoops))
+ .function((User rewrittenUser) -> convertAndRecurseMapping(associatedMapping, originalUser, rewrittenUser, remainingLoops))
.sneakyThrow();
return associatedMapping.rewriteUser(originalUser)
@@ -136,18 +136,17 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
.orElse(Stream.empty());
}
- private Stream<Mapping> convertAndRecurseMapping(Type mappingType, User originalUser, User rewrittenUser, int remainingLoops) throws ErrorMappingException, RecipientRewriteTableException {
+ private Stream<Mapping> convertAndRecurseMapping(Mapping mapping, User originalUser, User rewrittenUser, int remainingLoops) throws ErrorMappingException, RecipientRewriteTableException {
LOGGER.debug("Valid virtual user mapping {} to {}", originalUser, rewrittenUser);
- Stream<Mapping> nonRecursiveResult = Stream.of(toMapping(rewrittenUser, mappingType));
+ Stream<Mapping> nonRecursiveResult = Stream.of(toMapping(rewrittenUser, mapping.getType()));
if (!recursive) {
return nonRecursiveResult;
}
// Check if the returned mapping is the same as the input. If so we need to handle identity to avoid loops.
if (originalUser.equals(rewrittenUser)) {
- return mappingType.getIdentityMappingBehaviour()
- .handleIdentity(nonRecursiveResult);
+ return mapping.handleIdentity(nonRecursiveResult);
} else {
return recurseMapping(nonRecursiveResult, rewrittenUser, remainingLoops);
}
@@ -167,12 +166,12 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
switch (type) {
case Forward:
case Group:
- return MappingImpl.of(type, rewrittenUser.asString());
+ return Mapping.of(type, rewrittenUser.asString());
case Regex:
case Domain:
case Error:
case Address:
- return MappingImpl.address(rewrittenUser.asString());
+ return Mapping.address(rewrittenUser.asString());
}
throw new IllegalArgumentException("unhandled enum type");
}
@@ -185,7 +184,7 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
throw new RecipientRewriteTableException("Invalid regex: " + regex, e);
}
- MappingImpl mapping = MappingImpl.regex(regex);
+ Mapping mapping = Mapping.regex(regex);
checkMapping(user, domain, mapping);
LOGGER.info("Add regex mapping => {} for user: {} domain: {}", regex, user, domain.name());
addMapping(user, domain, mapping);
@@ -195,12 +194,12 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
@Override
public void removeRegexMapping(String user, Domain domain, String regex) throws RecipientRewriteTableException {
LOGGER.info("Remove regex mapping => {} for user: {} domain: {}", regex, user, domain.name());
- removeMapping(user, domain, MappingImpl.regex(regex));
+ removeMapping(user, domain, Mapping.regex(regex));
}
@Override
public void addAddressMapping(String user, Domain domain, String address) throws RecipientRewriteTableException {
- Mapping mapping = MappingImpl.address(address)
+ Mapping mapping = Mapping.address(address)
.appendDomainFromThrowingSupplierIfNone(this::defaultDomain);
checkHasValidAddress(mapping);
@@ -226,7 +225,7 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
@Override
public void removeAddressMapping(String user, Domain domain, String address) throws RecipientRewriteTableException {
- Mapping mapping = MappingImpl.address(address)
+ Mapping mapping = Mapping.address(address)
.appendDomainFromThrowingSupplierIfNone(this::defaultDomain);
LOGGER.info("Remove address mapping => {} for user: {} domain: {}", mapping, user, domain.name());
@@ -235,7 +234,7 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
@Override
public void addErrorMapping(String user, Domain domain, String error) throws RecipientRewriteTableException {
- MappingImpl mapping = MappingImpl.error(error);
+ Mapping mapping = Mapping.error(error);
checkMapping(user, domain, mapping);
LOGGER.info("Add error mapping => {} for user: {} domain: {}", error, user, domain.name());
@@ -246,7 +245,7 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
@Override
public void removeErrorMapping(String user, Domain domain, String error) throws RecipientRewriteTableException {
LOGGER.info("Remove error mapping => {} for user: {} domain: {}", error, user, domain.name());
- removeMapping(user, domain, MappingImpl.error(error));
+ removeMapping(user, domain, Mapping.error(error));
}
@Override
@@ -260,18 +259,18 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
@Override
public void addAliasDomainMapping(Domain aliasDomain, Domain realDomain) throws RecipientRewriteTableException {
LOGGER.info("Add domain mapping: {} => {}", aliasDomain, realDomain);
- addMapping(null, aliasDomain, MappingImpl.domain(realDomain));
+ addMapping(null, aliasDomain, Mapping.domain(realDomain));
}
@Override
public void removeAliasDomainMapping(Domain aliasDomain, Domain realDomain) throws RecipientRewriteTableException {
LOGGER.info("Remove domain mapping: {} => {}", aliasDomain, realDomain);
- removeMapping(null, aliasDomain, MappingImpl.domain(realDomain));
+ removeMapping(null, aliasDomain, Mapping.domain(realDomain));
}
@Override
public void addForwardMapping(String user, Domain domain, String address) throws RecipientRewriteTableException {
- Mapping mapping = MappingImpl.forward(address)
+ Mapping mapping = Mapping.forward(address)
.appendDomainFromThrowingSupplierIfNone(this::defaultDomain);
checkHasValidAddress(mapping);
@@ -283,7 +282,7 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
@Override
public void removeForwardMapping(String user, Domain domain, String address) throws RecipientRewriteTableException {
- Mapping mapping = MappingImpl.forward(address)
+ Mapping mapping = Mapping.forward(address)
.appendDomainFromThrowingSupplierIfNone(this::defaultDomain);
LOGGER.info("Remove forward mapping => {} for user: {} domain: {}", mapping, user, domain.name());
@@ -292,7 +291,7 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
@Override
public void addGroupMapping(String user, Domain domain, String address) throws RecipientRewriteTableException {
- Mapping mapping = MappingImpl.group(address)
+ Mapping mapping = Mapping.group(address)
.appendDomainFromThrowingSupplierIfNone(this::defaultDomain);
checkHasValidAddress(mapping);
@@ -304,7 +303,7 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
@Override
public void removeGroupMapping(String user, Domain domain, String address) throws RecipientRewriteTableException {
- Mapping mapping = MappingImpl.group(address)
+ Mapping mapping = Mapping.group(address)
.appendDomainFromThrowingSupplierIfNone(this::defaultDomain);
LOGGER.info("Remove forward mapping => {} for user: {} domain: {}", mapping, user, domain.name());
http://git-wip-us.apache.org/repos/asf/james-project/blob/1ba2bfc3/server/data/data-library/src/main/java/org/apache/james/rrt/lib/MappingImpl.java
----------------------------------------------------------------------
diff --git a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/MappingImpl.java b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/MappingImpl.java
deleted file mode 100644
index 87a2f8b..0000000
--- a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/MappingImpl.java
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- * 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.rrt.lib;
-
-import java.io.Serializable;
-import java.util.Optional;
-import java.util.function.Supplier;
-
-import javax.mail.internet.AddressException;
-
-import org.apache.james.core.Domain;
-import org.apache.james.core.MailAddress;
-import org.apache.james.core.User;
-import org.apache.james.rrt.api.RecipientRewriteTableException;
-
-import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-
-public class MappingImpl implements Mapping, Serializable {
-
- private static final long serialVersionUID = 1L;
-
- public static MappingImpl of(String mapping) {
- Type type = Mapping.detectType(mapping);
- return new MappingImpl(type, type.withoutPrefix(mapping));
- }
-
- public static MappingImpl of(Type type, String mapping) {
- return new MappingImpl(type, mapping);
- }
-
- public static MappingImpl address(String mapping) {
- return new MappingImpl(Type.Address, mapping);
- }
-
- public static MappingImpl regex(String mapping) {
- return new MappingImpl(Type.Regex, mapping);
- }
-
- public static MappingImpl error(String mapping) {
- return new MappingImpl(Type.Error, mapping);
- }
-
- public static MappingImpl domain(Domain mapping) {
- return new MappingImpl(Type.Domain, mapping.asString());
- }
-
- public static MappingImpl forward(String mapping) {
- return new MappingImpl(Type.Forward, mapping);
- }
-
- public static MappingImpl group(String mapping) {
- return new MappingImpl(Type.Group, mapping);
- }
-
- private final Type type;
- private final String mapping;
-
- private MappingImpl(Type type, String mapping) {
- Preconditions.checkNotNull(type);
- Preconditions.checkNotNull(mapping);
- this.type = type;
- this.mapping = mapping;
- }
-
- @Override
- public String asString() {
- return type.asPrefix() + mapping;
- }
-
- @Override
- public boolean hasDomain() {
- return mapping.contains("@");
- }
-
- @Override
- public Mapping appendDomainFromThrowingSupplierIfNone(ThrowingDomainSupplier supplier) throws RecipientRewriteTableException {
- Preconditions.checkNotNull(supplier);
- if (hasDomain()) {
- return this;
- }
- return appendDomain(supplier.get());
- }
-
- @Override
- public Mapping appendDomainIfNone(Supplier<Domain> domain) {
- Preconditions.checkNotNull(domain);
- if (hasDomain()) {
- return this;
- }
- return appendDomain(domain.get());
- }
-
- private MappingImpl appendDomain(Domain domain) {
- return new MappingImpl(type, mapping + "@" + domain.asString());
- }
-
- @Override
- public Type getType() {
- return type;
- }
-
- @Override
- public String getErrorMessage() {
- Preconditions.checkState(getType() == Type.Error);
- return mapping;
- }
-
- @Override
- public Optional<MailAddress> asMailAddress() {
- if (type != Type.Address && type != Type.Forward && type != Type.Group) {
- return Optional.empty();
- }
- try {
- return Optional.of(new MailAddress(mapping));
- } catch (AddressException e) {
- return Optional.empty();
- }
- }
-
- @Override
- public Optional<User> rewriteUser(User user) throws AddressException {
- return type.rewriter(mapping)
- .rewrite(user);
- }
-
- @Override
- public final boolean equals(Object other) {
- if (other instanceof MappingImpl) {
- MappingImpl otherMapping = (MappingImpl) other;
- return Objects.equal(type, otherMapping.type)
- && Objects.equal(mapping, otherMapping.mapping);
- }
- return false;
- }
-
- @Override
- public final int hashCode() {
- return Objects.hashCode(type, mapping);
- }
-
- @Override
- public String toString() {
- return "MappingImpl{type=" + type + " mapping=" + mapping + "}";
- }
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/james-project/blob/1ba2bfc3/server/data/data-library/src/main/java/org/apache/james/rrt/lib/MappingsImpl.java
----------------------------------------------------------------------
diff --git a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/MappingsImpl.java b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/MappingsImpl.java
index 3b56c9e..6c042ff 100644
--- a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/MappingsImpl.java
+++ b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/MappingsImpl.java
@@ -99,7 +99,7 @@ public class MappingsImpl implements Mappings, Serializable {
public static MappingsImpl fromCollection(Collection<String> mappings) {
return fromMappings(mappings.stream()
- .map(MappingImpl::of));
+ .map(Mapping::of));
}
public static MappingsImpl fromMappings(Stream<Mapping> mappings) {
@@ -131,7 +131,7 @@ public class MappingsImpl implements Mappings, Serializable {
}
public Builder add(String mapping) {
- return add(MappingImpl.of(mapping));
+ return add(Mapping.of(mapping));
}
public Builder add(Mapping mapping) {
http://git-wip-us.apache.org/repos/asf/james-project/blob/1ba2bfc3/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableManagement.java
----------------------------------------------------------------------
diff --git a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableManagement.java b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableManagement.java
index 3da96e3..14aa1c8 100644
--- a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableManagement.java
+++ b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/RecipientRewriteTableManagement.java
@@ -91,12 +91,12 @@ public class RecipientRewriteTableManagement extends StandardMBean implements Re
@Override
public void addMapping(String user, String domain, String mapping) throws RecipientRewriteTableException {
- rrt.addMapping(user, Domain.of(domain), MappingImpl.of(mapping));
+ rrt.addMapping(user, Domain.of(domain), Mapping.of(mapping));
}
@Override
public void removeMapping(String user, String domain, String mapping) throws RecipientRewriteTableException {
- rrt.removeMapping(user, Domain.of(domain), MappingImpl.of(mapping));
+ rrt.removeMapping(user, Domain.of(domain), Mapping.of(mapping));
}
@Override
http://git-wip-us.apache.org/repos/asf/james-project/blob/1ba2bfc3/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java
----------------------------------------------------------------------
diff --git a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java b/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java
index 84f204d..2873feb 100644
--- a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java
+++ b/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java
@@ -73,7 +73,7 @@ public abstract class AbstractRecipientRewriteTableTest {
public void testStoreAndGetMappings() throws ErrorMappingException, RecipientRewriteTableException {
String user = "*";
Domain domain = Domain.of("test");
- virtualUserTable.addMapping(user, domain, MappingImpl.regex("prefix_.*:admin@test"));
+ virtualUserTable.addMapping(user, domain, Mapping.regex("prefix_.*:admin@test"));
assertThat(virtualUserTable.getMappings("prefix_abc", domain)).isNotEmpty();
}
@@ -90,18 +90,18 @@ public abstract class AbstractRecipientRewriteTableTest {
assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping")
.isEqualTo(MappingsImpl.empty());
- virtualUserTable.addMapping(user, domain, MappingImpl.regex(regex));
- virtualUserTable.addMapping(user, domain, MappingImpl.regex(regex2));
+ virtualUserTable.addMapping(user, domain, Mapping.regex(regex));
+ virtualUserTable.addMapping(user, domain, Mapping.regex(regex2));
assertThat(virtualUserTable.getMappings(user, domain)).describedAs("Two mappings").hasSize(2);
assertThat(virtualUserTable.getAllMappings()).describedAs("One mappingline").hasSize(1);
- virtualUserTable.removeMapping(user, domain, MappingImpl.regex(regex));
+ virtualUserTable.removeMapping(user, domain, Mapping.regex(regex));
assertThatThrownBy(() -> virtualUserTable.addRegexMapping(user, domain, invalidRegex))
.describedAs("Invalid Mapping throw exception")
.isInstanceOf(RecipientRewriteTableException.class);
- virtualUserTable.removeMapping(user, domain, MappingImpl.regex(regex2));
+ virtualUserTable.removeMapping(user, domain, Mapping.regex(regex2));
assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping")
@@ -116,19 +116,19 @@ public abstract class AbstractRecipientRewriteTableTest {
String regex = "(.*)@localhost";
String regex2 = "(.+)@test";
- virtualUserTable.addMapping(user, Domain.LOCALHOST, MappingImpl.regex(regex));
- virtualUserTable.addMapping(user, Domain.LOCALHOST, MappingImpl.regex(regex2));
- virtualUserTable.addMapping(user2, Domain.LOCALHOST, MappingImpl.address(user + "@" + Domain.LOCALHOST.asString()));
+ virtualUserTable.addMapping(user, Domain.LOCALHOST, Mapping.regex(regex));
+ virtualUserTable.addMapping(user, Domain.LOCALHOST, Mapping.regex(regex2));
+ virtualUserTable.addMapping(user2, Domain.LOCALHOST, Mapping.address(user + "@" + Domain.LOCALHOST.asString()));
assertThat(virtualUserTable.getAllMappings())
.describedAs("One mappingline")
.containsOnly(
Pair.of(user + "@" + Domain.LOCALHOST.asString(), MappingsImpl.builder()
- .add(MappingImpl.regex(regex))
- .add(MappingImpl.regex(regex2))
+ .add(Mapping.regex(regex))
+ .add(Mapping.regex(regex2))
.build()),
Pair.of(user2 + "@" + Domain.LOCALHOST.asString(), MappingsImpl.builder()
- .add(MappingImpl.address(user + "@" + Domain.LOCALHOST.asString()))
+ .add(Mapping.address(user + "@" + Domain.LOCALHOST.asString()))
.build()));
}
@@ -143,14 +143,14 @@ public abstract class AbstractRecipientRewriteTableTest {
assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping")
.isEqualTo(MappingsImpl.empty());
- virtualUserTable.addMapping(user, domain, MappingImpl.address(address));
- virtualUserTable.addMapping(user, domain, MappingImpl.address(address2));
+ virtualUserTable.addMapping(user, domain, Mapping.address(address));
+ virtualUserTable.addMapping(user, domain, Mapping.address(address2));
assertThat(virtualUserTable.getMappings(user, domain)).describedAs("Two mappings").hasSize(2);
assertThat(virtualUserTable.getAllMappings()).describedAs("One mappingline").hasSize(1);
- virtualUserTable.removeMapping(user, domain, MappingImpl.address(address));
- virtualUserTable.removeMapping(user, domain, MappingImpl.address(address2));
+ virtualUserTable.removeMapping(user, domain, Mapping.address(address));
+ virtualUserTable.removeMapping(user, domain, Mapping.address(address2));
assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping")
.isEqualTo(MappingsImpl.empty());
@@ -166,7 +166,7 @@ public abstract class AbstractRecipientRewriteTableTest {
assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping")
.isEqualTo(MappingsImpl.empty());
- virtualUserTable.addMapping(user, domain, MappingImpl.error(error));
+ virtualUserTable.addMapping(user, domain, Mapping.error(error));
assertThat(virtualUserTable.getAllMappings()).describedAs("One mappingline").hasSize(1);
assertThatThrownBy(() ->
@@ -174,7 +174,7 @@ public abstract class AbstractRecipientRewriteTableTest {
.describedAs("Exception thrown on to many mappings")
.isInstanceOf(ErrorMappingException.class);
- virtualUserTable.removeMapping(user, domain, MappingImpl.error(error));
+ virtualUserTable.removeMapping(user, domain, Mapping.error(error));
assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping")
.isEqualTo(MappingsImpl.empty());
@@ -192,14 +192,14 @@ public abstract class AbstractRecipientRewriteTableTest {
assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping")
.isEqualTo(MappingsImpl.empty());
- virtualUserTable.addMapping(RecipientRewriteTable.WILDCARD, domain, MappingImpl.address(address));
- virtualUserTable.addMapping(user, domain, MappingImpl.address(address2));
+ virtualUserTable.addMapping(RecipientRewriteTable.WILDCARD, domain, Mapping.address(address));
+ virtualUserTable.addMapping(user, domain, Mapping.address(address2));
assertThat(virtualUserTable.getMappings(user, domain)).describedAs("One mappings").hasSize(1);
assertThat(virtualUserTable.getMappings(user2, domain)).describedAs("One mappings").hasSize(1);
- virtualUserTable.removeMapping(user, domain, MappingImpl.address(address2));
- virtualUserTable.removeMapping(RecipientRewriteTable.WILDCARD, domain, MappingImpl.address(address));
+ virtualUserTable.removeMapping(user, domain, Mapping.address(address2));
+ virtualUserTable.removeMapping(RecipientRewriteTable.WILDCARD, domain, Mapping.address(address));
assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping")
.isEqualTo(MappingsImpl.empty());
@@ -220,10 +220,10 @@ public abstract class AbstractRecipientRewriteTableTest {
assertThat(virtualUserTable.getAllMappings()).describedAs("No mapping").isEmpty();
- virtualUserTable.addMapping(user1, domain1, MappingImpl.address(user2 + "@" + domain2.asString()));
- virtualUserTable.addMapping(user2, domain2, MappingImpl.address(user3 + "@" + domain3.asString()));
- assertThat(virtualUserTable.getMappings(user1, domain1)).containsOnly(MappingImpl.address(user3 + "@" + domain3.asString()));
- virtualUserTable.addMapping(user3, domain3, MappingImpl.address(user1 + "@" + domain1.asString()));
+ virtualUserTable.addMapping(user1, domain1, Mapping.address(user2 + "@" + domain2.asString()));
+ virtualUserTable.addMapping(user2, domain2, Mapping.address(user3 + "@" + domain3.asString()));
+ assertThat(virtualUserTable.getMappings(user1, domain1)).containsOnly(Mapping.address(user3 + "@" + domain3.asString()));
+ virtualUserTable.addMapping(user3, domain3, Mapping.address(user1 + "@" + domain1.asString()));
assertThatThrownBy(() ->
virtualUserTable.getMappings(user1, domain1))
@@ -232,7 +232,7 @@ public abstract class AbstractRecipientRewriteTableTest {
// disable recursive mapping
virtualUserTable.setRecursiveMapping(false);
- assertThat(virtualUserTable.getMappings(user1, domain1)).describedAs("Not recursive mapped").containsExactly(MappingImpl.address(user2 + "@" + domain2.asString()));
+ assertThat(virtualUserTable.getMappings(user1, domain1)).describedAs("Not recursive mapped").containsExactly(Mapping.address(user2 + "@" + domain2.asString()));
}
@Test
@@ -244,18 +244,18 @@ public abstract class AbstractRecipientRewriteTableTest {
assertThat(virtualUserTable.getAllMappings()).describedAs("No mappings").isEmpty();
- virtualUserTable.addMapping(RecipientRewriteTable.WILDCARD, aliasDomain, MappingImpl.address(user2 + "@" + domain));
- virtualUserTable.addMapping(RecipientRewriteTable.WILDCARD, aliasDomain, MappingImpl.domain(Domain.of(domain)));
+ virtualUserTable.addMapping(RecipientRewriteTable.WILDCARD, aliasDomain, Mapping.address(user2 + "@" + domain));
+ virtualUserTable.addMapping(RecipientRewriteTable.WILDCARD, aliasDomain, Mapping.domain(Domain.of(domain)));
assertThat(virtualUserTable.getMappings(user, aliasDomain))
.describedAs("Domain mapped as first, Address mapped as second")
.isEqualTo(MappingsImpl.builder()
- .add(MappingImpl.address(user + "@" + domain))
- .add(MappingImpl.address(user2 + "@" + domain))
+ .add(Mapping.address(user + "@" + domain))
+ .add(Mapping.address(user2 + "@" + domain))
.build());
- virtualUserTable.removeMapping(RecipientRewriteTable.WILDCARD, aliasDomain, MappingImpl.address(user2 + "@" + domain));
- virtualUserTable.removeMapping(RecipientRewriteTable.WILDCARD, aliasDomain, MappingImpl.domain(Domain.of(domain)));
+ virtualUserTable.removeMapping(RecipientRewriteTable.WILDCARD, aliasDomain, Mapping.address(user2 + "@" + domain));
+ virtualUserTable.removeMapping(RecipientRewriteTable.WILDCARD, aliasDomain, Mapping.domain(Domain.of(domain)));
}
@Test
@@ -276,8 +276,8 @@ public abstract class AbstractRecipientRewriteTableTest {
Domain domain = Domain.LOCALHOST;
String address = "test@localhost2";
- virtualUserTable.addMapping(user, domain, MappingImpl.address(address));
- virtualUserTable.addMapping(user, domain, MappingImpl.regex(address));
+ virtualUserTable.addMapping(user, domain, Mapping.address(address));
+ virtualUserTable.addMapping(user, domain, Mapping.regex(address));
assertThat(virtualUserTable.getMappings(user, domain)).hasSize(2);
}
@@ -289,8 +289,8 @@ public abstract class AbstractRecipientRewriteTableTest {
String address = "test@localhost2";
String address2 = "test@james";
- virtualUserTable.addMapping(user, domain, MappingImpl.forward(address));
- virtualUserTable.addMapping(user, domain, MappingImpl.forward(address2));
+ virtualUserTable.addMapping(user, domain, Mapping.forward(address));
+ virtualUserTable.addMapping(user, domain, Mapping.forward(address2));
assertThat(virtualUserTable.getMappings(user, domain)).hasSize(2);
}
@@ -302,11 +302,11 @@ public abstract class AbstractRecipientRewriteTableTest {
String address = "test@localhost2";
String address2 = "test@james";
- virtualUserTable.addMapping(user, domain, MappingImpl.forward(address));
- virtualUserTable.addMapping(user, domain, MappingImpl.forward(address2));
+ virtualUserTable.addMapping(user, domain, Mapping.forward(address));
+ virtualUserTable.addMapping(user, domain, Mapping.forward(address2));
- virtualUserTable.removeMapping(user, domain, MappingImpl.forward(address));
- virtualUserTable.removeMapping(user, domain, MappingImpl.forward(address2));
+ virtualUserTable.removeMapping(user, domain, Mapping.forward(address));
+ virtualUserTable.removeMapping(user, domain, Mapping.forward(address2));
assertThat(virtualUserTable.getMappings(user, domain))
.isEqualTo(MappingsImpl.empty());
@@ -319,8 +319,8 @@ public abstract class AbstractRecipientRewriteTableTest {
String address = "test@localhost2";
String address2 = "test@james";
- virtualUserTable.addMapping(user, domain, MappingImpl.group(address));
- virtualUserTable.addMapping(user, domain, MappingImpl.group(address2));
+ virtualUserTable.addMapping(user, domain, Mapping.group(address));
+ virtualUserTable.addMapping(user, domain, Mapping.group(address2));
assertThat(virtualUserTable.getMappings(user, domain)).hasSize(2);
}
@@ -332,11 +332,11 @@ public abstract class AbstractRecipientRewriteTableTest {
String address = "test@localhost2";
String address2 = "test@james";
- virtualUserTable.addMapping(user, domain, MappingImpl.group(address));
- virtualUserTable.addMapping(user, domain, MappingImpl.group(address2));
+ virtualUserTable.addMapping(user, domain, Mapping.group(address));
+ virtualUserTable.addMapping(user, domain, Mapping.group(address2));
- virtualUserTable.removeMapping(user, domain, MappingImpl.group(address));
- virtualUserTable.removeMapping(user, domain, MappingImpl.group(address2));
+ virtualUserTable.removeMapping(user, domain, Mapping.group(address));
+ virtualUserTable.removeMapping(user, domain, Mapping.group(address2));
assertThat(virtualUserTable.getMappings(user, domain))
.isEqualTo(MappingsImpl.empty());
http://git-wip-us.apache.org/repos/asf/james-project/blob/1ba2bfc3/server/data/data-library/src/test/java/org/apache/james/rrt/lib/MappingImplTest.java
----------------------------------------------------------------------
diff --git a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/MappingImplTest.java b/server/data/data-library/src/test/java/org/apache/james/rrt/lib/MappingImplTest.java
deleted file mode 100644
index 8b16443..0000000
--- a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/MappingImplTest.java
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
- * 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.rrt.lib;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-import org.apache.james.core.Domain;
-import org.apache.james.core.MailAddress;
-import org.apache.james.rrt.api.RecipientRewriteTableException;
-import org.junit.Test;
-
-import nl.jqno.equalsverifier.EqualsVerifier;
-
-public class MappingImplTest {
-
- @Test
- public void beanShouldRespectBeanContract() {
- EqualsVerifier.forClass(MappingImpl.class)
- .verify();
- }
-
- @Test
- public void addressFactoryMethodShouldThrowOnNull() {
- assertThatThrownBy(() -> MappingImpl.address(null))
- .isInstanceOf(NullPointerException.class);
- }
-
- @Test
- public void regexFactoryMethodShouldThrowOnNull() {
- assertThatThrownBy(() -> MappingImpl.regex(null))
- .isInstanceOf(NullPointerException.class);
- }
-
- @Test
- public void domainFactoryMethodShouldThrowOnNull() {
- assertThatThrownBy(() -> MappingImpl.domain(null))
- .isInstanceOf(NullPointerException.class);
- }
-
- @Test
- public void errorFactoryMethodShouldThrowOnNull() {
- assertThatThrownBy(() -> MappingImpl.error(null))
- .isInstanceOf(NullPointerException.class);
- }
-
- @Test
- public void forwardFactoryMethodShouldThrowOnNull() {
- assertThatThrownBy(() -> MappingImpl.forward(null))
- .isInstanceOf(NullPointerException.class);
- }
-
- @Test
- public void groupFactoryMethodShouldThrowOnNull() {
- assertThatThrownBy(() -> MappingImpl.group(null))
- .isInstanceOf(NullPointerException.class);
- }
-
- @Test
- public void hasDomainShouldReturnTrueWhenMappingContainAtMark() {
- assertThat(MappingImpl.address("a@b").hasDomain()).isTrue();
- }
-
- @Test
- public void hasDomainShouldReturnFalseWhenMappingIsEmpty() {
- assertThat(MappingImpl.address("").hasDomain()).isFalse();
- }
-
- @Test
- public void hasDomainShouldReturnFalseWhenMappingIsBlank() {
- assertThat(MappingImpl.address(" ").hasDomain()).isFalse();
- }
-
- @Test
- public void hasDomainShouldReturnFalseWhenMappingDoesntContainAtMark() {
- assertThat(MappingImpl.address("abc").hasDomain()).isFalse();
- }
-
- @Test
- public void appendDefaultDomainShouldWorkOnValidDomain() {
- assertThat(MappingImpl.address("abc").appendDomainIfNone(() -> Domain.of("domain"))).isEqualTo(MappingImpl.address("abc@domain"));
- }
-
- @Test
- public void appendDefaultDomainShouldNotAddDomainWhenMappingAlreadyContainsDomains() {
- assertThat(MappingImpl.address("abc@d").appendDomainIfNone(() -> Domain.of("domain"))).isEqualTo(MappingImpl.address("abc@d"));
- }
-
- @Test
- public void appendDomainShouldThrowWhenNullDomain() {
- assertThatThrownBy(() -> MappingImpl.address("abc@d").appendDomainIfNone(null)).isInstanceOf(NullPointerException.class);
- }
-
- @Test
- public void appendDomainFromThrowingSupplierIfNoneShouldWorkOnValidDomain() throws RecipientRewriteTableException {
- assertThat(MappingImpl.address("abc").appendDomainFromThrowingSupplierIfNone(() -> Domain.of("domain")))
- .isEqualTo(MappingImpl.address("abc@domain"));
- }
-
- @Test
- public void appendDomainFromThrowingSupplierIfNoneShouldNotAddDomainWhenMappingAlreadyContainsDomains() throws RecipientRewriteTableException {
- assertThat(MappingImpl.address("abc@d").appendDomainFromThrowingSupplierIfNone(() -> Domain.of("domain")))
- .isEqualTo(MappingImpl.address("abc@d"));
- }
-
- @Test
- public void appendDomainFromThrowingSupplierIfNoneShouldThrowWhenNullDomain() {
- assertThatThrownBy(() -> MappingImpl.address("abc@d").appendDomainFromThrowingSupplierIfNone(null))
- .isInstanceOf(NullPointerException.class);
- }
-
- @Test
- public void appendDomainFromThrowingSupplierIfNoneShouldNotCatchRecipientRewriteTableException() {
- Mapping.ThrowingDomainSupplier supplier = () -> {
- throw new RecipientRewriteTableException("message");
- };
- assertThatThrownBy(() -> MappingImpl.address("abc").appendDomainFromThrowingSupplierIfNone(supplier))
- .isInstanceOf(RecipientRewriteTableException.class);
- }
-
- @Test
- public void getTypeShouldReturnAddressWhenNoPrefix() {
- assertThat(MappingImpl.address("abc").getType()).isEqualTo(Mapping.Type.Address);
- }
-
- @Test
- public void getTypeShouldReturnAddressWhenEmpty() {
- assertThat(MappingImpl.address("").getType()).isEqualTo(Mapping.Type.Address);
- }
-
- @Test
- public void getTypeShouldReturnRegexWhenRegexPrefix() {
- assertThat(MappingImpl.regex("abc").getType()).isEqualTo(Mapping.Type.Regex);
- }
-
- @Test
- public void getTypeShouldReturnErrorWhenErrorPrefix() {
- assertThat(MappingImpl.error("abc").getType()).isEqualTo(Mapping.Type.Error);
- }
-
- @Test
- public void getTypeShouldReturnDomainWhenDomainPrefix() {
- assertThat(MappingImpl.domain(Domain.of("abc")).getType()).isEqualTo(Mapping.Type.Domain);
- }
-
- @Test
- public void getTypeShouldReturnForwardWhenForwardPrefix() {
- assertThat(MappingImpl.forward("abc").getType()).isEqualTo(Mapping.Type.Forward);
- }
-
- @Test
- public void getTypeShouldReturnGroupWhenGroupPrefix() {
- assertThat(MappingImpl.group("abc").getType()).isEqualTo(Mapping.Type.Group);
- }
-
- @Test(expected = IllegalStateException.class)
- public void getErrorMessageShouldThrowWhenMappingIsNotAnError() {
- MappingImpl.domain(Domain.of("toto")).getErrorMessage();
- }
-
- @Test
- public void getErrorMessageShouldReturnMessageWhenErrorWithMessage() {
- assertThat(MappingImpl.error("toto").getErrorMessage()).isEqualTo("toto");
- }
-
- @Test
- public void getErrorMessageShouldReturnWhenErrorWithoutMessage() {
- assertThat(MappingImpl.error("").getErrorMessage()).isEqualTo("");
- }
-
- @Test
- public void asMailAddressShouldReturnMappingValueForAddress() throws Exception {
- assertThat(MappingImpl.address("value@domain").asMailAddress())
- .contains(new MailAddress("value@domain"));
- }
-
- @Test
- public void asMailAddressShouldReturnEmptyOnInvalidAddress() {
- assertThat(MappingImpl.address("value").asMailAddress())
- .isEmpty();
- }
-
- @Test
- public void asMailAddressShouldReturnEmptyForError() {
- assertThat(MappingImpl.error("value").asMailAddress()).isEmpty();
- }
-
- @Test
- public void asMailAddressShouldReturnEmptyForRegex() {
- assertThat(MappingImpl.regex("value").asMailAddress()).isEmpty();
- }
-
- @Test
- public void asMailAddressShouldReturnEmptyForDomain() {
- assertThat(MappingImpl.domain(Domain.of("value")).asMailAddress()).isEmpty();
- }
-
- @Test
- public void asMailAddressShouldReturnMappingValueForForward() throws Exception {
- assertThat(MappingImpl.forward("value@domain").asMailAddress())
- .contains(new MailAddress("value@domain"));
- }
-}
http://git-wip-us.apache.org/repos/asf/james-project/blob/1ba2bfc3/server/data/data-library/src/test/java/org/apache/james/rrt/lib/MappingsImplTest.java
----------------------------------------------------------------------
diff --git a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/MappingsImplTest.java b/server/data/data-library/src/test/java/org/apache/james/rrt/lib/MappingsImplTest.java
index 213c3d1..afae9e2 100644
--- a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/MappingsImplTest.java
+++ b/server/data/data-library/src/test/java/org/apache/james/rrt/lib/MappingsImplTest.java
@@ -45,82 +45,82 @@ public class MappingsImplTest {
@Test
public void fromRawStringShouldReturnSingletonCollectionWhenSingleElementString() {
MappingsImpl actual = MappingsImpl.fromRawString("value");
- assertThat(actual).containsOnly(MappingImpl.address("value"));
+ assertThat(actual).containsOnly(Mapping.address("value"));
}
@Test
public void fromRawStringShouldReturnCollectionWhenSeveralElementsString() {
MappingsImpl actual = MappingsImpl.fromRawString("value1;value2");
- assertThat(actual).containsOnly(MappingImpl.address("value1"), MappingImpl.address("value2"));
+ assertThat(actual).containsOnly(Mapping.address("value1"), Mapping.address("value2"));
}
@Test
public void fromRawStringShouldReturnSingleElementCollectionWhenTrailingDelimiterString() {
MappingsImpl actual = MappingsImpl.fromRawString("value1;");
- assertThat(actual).containsOnly(MappingImpl.address("value1"));
+ assertThat(actual).containsOnly(Mapping.address("value1"));
}
@Test
public void fromRawStringShouldReturnSingleElementCollectionWhenHeadingDelimiterString() {
MappingsImpl actual = MappingsImpl.fromRawString(";value1");
- assertThat(actual).containsOnly(MappingImpl.address("value1"));
+ assertThat(actual).containsOnly(Mapping.address("value1"));
}
@Test
public void fromRawStringShouldTrimValues() {
MappingsImpl actual = MappingsImpl.fromRawString("value1 ; value2 ");
- assertThat(actual).containsOnly(MappingImpl.address("value1"), MappingImpl.address("value2"));
+ assertThat(actual).containsOnly(Mapping.address("value1"), Mapping.address("value2"));
}
@Test
public void fromRawStringShouldNotSkipEmptyValue() {
MappingsImpl actual = MappingsImpl.fromRawString("value1; ;value2");
- assertThat(actual).containsOnly(MappingImpl.address("value1"), MappingImpl.address(""), MappingImpl.address("value2"));
+ assertThat(actual).containsOnly(Mapping.address("value1"), Mapping.address(""), Mapping.address("value2"));
}
@Test
public void fromRawStringShouldReturnCollectionWhenValueContainsCommaSeperatedValues() {
MappingsImpl actual = MappingsImpl.fromRawString("value1,value2");
- assertThat(actual).containsOnly(MappingImpl.address("value1"),MappingImpl.address("value2"));
+ assertThat(actual).containsOnly(Mapping.address("value1"),Mapping.address("value2"));
}
@Test
public void fromRawStringShouldReturnCollectionWhenValueContainsColonSeperatedValues() {
MappingsImpl actual = MappingsImpl.fromRawString("value1:value2");
- assertThat(actual).containsOnly(MappingImpl.address("value1"),MappingImpl.address("value2"));
+ assertThat(actual).containsOnly(Mapping.address("value1"),Mapping.address("value2"));
}
@Test
public void fromRawStringShouldUseCommaDelimiterBeforeSemicolonWhenValueContainsBoth() {
MappingsImpl actual = MappingsImpl.fromRawString("value1;value1,value2");
- assertThat(actual).containsOnly(MappingImpl.address("value1;value1"),MappingImpl.address("value2"));
+ assertThat(actual).containsOnly(Mapping.address("value1;value1"),Mapping.address("value2"));
}
@Test
public void fromRawStringShouldUseSemicolonDelimiterBeforeColonWhenValueContainsBoth() {
MappingsImpl actual = MappingsImpl.fromRawString("value1:value1;value2");
- assertThat(actual).containsOnly(MappingImpl.address("value1:value1"),MappingImpl.address("value2"));
+ assertThat(actual).containsOnly(Mapping.address("value1:value1"),Mapping.address("value2"));
}
@Test
public void fromRawStringShouldNotUseColonDelimiterWhenValueStartsWithError() {
MappingsImpl actual = MappingsImpl.fromRawString("error:test");
- assertThat(actual).containsOnly(MappingImpl.error("test"));
+ assertThat(actual).containsOnly(Mapping.error("test"));
}
@Test
public void fromRawStringShouldNotUseColonDelimiterWhenValueStartsWithDomain() {
MappingsImpl actual = MappingsImpl.fromRawString("domain:test");
- assertThat(actual).containsOnly(MappingImpl.domain(Domain.of("test")));
+ assertThat(actual).containsOnly(Mapping.domain(Domain.of("test")));
}
@Test
public void fromRawStringShouldNotUseColonDelimiterWhenValueStartsWithRegex() {
MappingsImpl actual = MappingsImpl.fromRawString("regex:test");
- assertThat(actual).containsOnly(MappingImpl.regex("test"));
+ assertThat(actual).containsOnly(Mapping.regex("test"));
}
@Test
@@ -142,34 +142,34 @@ public class MappingsImplTest {
@Test
public void containsShouldReturnTrueWhenMatchingMapping() {
- MappingsImpl mappings = MappingsImpl.builder().add(MappingImpl.regex("toto")).build();
+ MappingsImpl mappings = MappingsImpl.builder().add(Mapping.regex("toto")).build();
assertThat(mappings.contains(Mapping.Type.Regex)).isTrue();
}
@Test
public void containsShouldReturnFalseWhenNoMatchingMapping() {
- MappingsImpl mappings = MappingsImpl.builder().add(MappingImpl.regex("toto")).build();
+ MappingsImpl mappings = MappingsImpl.builder().add(Mapping.regex("toto")).build();
assertThat(mappings.contains(Mapping.Type.Error)).isFalse();
}
@Test(expected = NullPointerException.class)
public void containsShouldThrowWhenNull() {
- MappingsImpl mappings = MappingsImpl.builder().add(MappingImpl.regex("toto")).build();
+ MappingsImpl mappings = MappingsImpl.builder().add(Mapping.regex("toto")).build();
assertThat(mappings.contains((Mapping.Type)null));
}
@Test
public void selectShouldReturnMatchingElementsInOrderWhenMatchingMapping() {
MappingsImpl mappings = MappingsImpl.builder()
- .add(MappingImpl.regex("toto"))
- .add(MappingImpl.address("toto"))
- .add(MappingImpl.domain(Domain.of("domain")))
- .add(MappingImpl.regex("tata"))
+ .add(Mapping.regex("toto"))
+ .add(Mapping.address("toto"))
+ .add(Mapping.domain(Domain.of("domain")))
+ .add(Mapping.regex("tata"))
.build();
MappingsImpl expected = MappingsImpl.builder()
- .add(MappingImpl.regex("toto"))
- .add(MappingImpl.regex("tata"))
+ .add(Mapping.regex("toto"))
+ .add(Mapping.regex("tata"))
.build();
assertThat(mappings.select(Mapping.Type.Regex)).isEqualTo(expected);
}
@@ -177,9 +177,9 @@ public class MappingsImplTest {
@Test
public void selectShouldReturnEmptyCollectionWhenNoMatchingMapping() {
MappingsImpl mappings = MappingsImpl.builder()
- .add(MappingImpl.regex("toto"))
- .add(MappingImpl.address("toto"))
- .add(MappingImpl.address("tata"))
+ .add(Mapping.regex("toto"))
+ .add(Mapping.address("toto"))
+ .add(Mapping.address("tata"))
.build();
assertThat(mappings.select(Mapping.Type.Domain)).isEqualTo(MappingsImpl.empty());
}
@@ -187,21 +187,21 @@ public class MappingsImplTest {
@Test(expected = NullPointerException.class)
public void selectShouldThrowWhenNull() {
- MappingsImpl mappings = MappingsImpl.builder().add(MappingImpl.regex("toto")).build();
+ MappingsImpl mappings = MappingsImpl.builder().add(Mapping.regex("toto")).build();
assertThat(mappings.select((Mapping.Type)null));
}
@Test
public void excludeShouldReturnNonMatchingElementsInOrderWhenNonMatchingMapping() {
MappingsImpl mappings = MappingsImpl.builder()
- .add(MappingImpl.regex("toto"))
- .add(MappingImpl.address("toto"))
- .add(MappingImpl.domain(Domain.of("domain")))
- .add(MappingImpl.regex("tata"))
+ .add(Mapping.regex("toto"))
+ .add(Mapping.address("toto"))
+ .add(Mapping.domain(Domain.of("domain")))
+ .add(Mapping.regex("tata"))
.build();
MappingsImpl expected = MappingsImpl.builder()
- .add(MappingImpl.address("toto"))
- .add(MappingImpl.domain(Domain.of("domain")))
+ .add(Mapping.address("toto"))
+ .add(Mapping.domain(Domain.of("domain")))
.build();
assertThat(mappings.exclude(Mapping.Type.Regex)).isEqualTo(expected);
}
@@ -209,8 +209,8 @@ public class MappingsImplTest {
@Test
public void excludeShouldReturnEmptyCollectionWhenOnlyMatchingMapping() {
MappingsImpl mappings = MappingsImpl.builder()
- .add(MappingImpl.address("toto"))
- .add(MappingImpl.address("tata"))
+ .add(Mapping.address("toto"))
+ .add(Mapping.address("tata"))
.build();
assertThat(mappings.exclude(Mapping.Type.Address)).isEqualTo(MappingsImpl.empty());
}
@@ -218,7 +218,7 @@ public class MappingsImplTest {
@Test(expected = NullPointerException.class)
public void excludeShouldThrowWhenNull() {
- MappingsImpl mappings = MappingsImpl.builder().add(MappingImpl.regex("toto")).build();
+ MappingsImpl mappings = MappingsImpl.builder().add(Mapping.regex("toto")).build();
assertThat(mappings.exclude((Mapping.Type)null));
}
@@ -252,7 +252,7 @@ public class MappingsImplTest {
@Test
public void unionShouldReturnMergedWhenBothContainsData() {
Mappings mappings = MappingsImpl.fromRawString("toto").union(MappingsImpl.fromRawString("tata"));
- assertThat(mappings).containsOnly(MappingImpl.address("toto"),MappingImpl.address("tata"));
+ assertThat(mappings).containsOnly(Mapping.address("toto"),Mapping.address("tata"));
}
@Test
@@ -280,7 +280,7 @@ public class MappingsImplTest {
@Test
public void mergeShouldReturnLeftWhenRightIsEmpty() {
- MappingImpl expectedMapping = MappingImpl.address("toto");
+ Mapping expectedMapping = Mapping.address("toto");
MappingsImpl.Builder left = MappingsImpl.builder().add(expectedMapping);
MappingsImpl.Builder empty = MappingsImpl.builder();
MappingsImpl mappingsImpl = MappingsImpl.Builder
@@ -291,7 +291,7 @@ public class MappingsImplTest {
@Test
public void mergeShouldReturnRightWhenLeftIsEmpty() {
- MappingImpl expectedMapping = MappingImpl.address("toto");
+ Mapping expectedMapping = Mapping.address("toto");
MappingsImpl.Builder right = MappingsImpl.builder().add(expectedMapping);
MappingsImpl.Builder empty = MappingsImpl.builder();
MappingsImpl mappingsImpl = MappingsImpl.Builder
@@ -302,9 +302,9 @@ public class MappingsImplTest {
@Test
public void mergeShouldReturnBothWhenBothAreNotEmpty() {
- MappingImpl leftMapping = MappingImpl.address("toto");
+ Mapping leftMapping = Mapping.address("toto");
MappingsImpl.Builder left = MappingsImpl.builder().add(leftMapping);
- MappingImpl rightMapping = MappingImpl.address("titi");
+ Mapping rightMapping = Mapping.address("titi");
MappingsImpl.Builder right = MappingsImpl.builder().add(rightMapping);
MappingsImpl mappingsImpl = MappingsImpl.Builder
.merge(left, right)
@@ -314,10 +314,10 @@ public class MappingsImplTest {
@Test
public void builderShouldPutDomainAliasFirstWhenVariousMappings() {
- MappingImpl addressMapping = MappingImpl.address("aaa");
- MappingImpl errorMapping = MappingImpl.error("error");
- MappingImpl domainMapping = MappingImpl.domain(Domain.of("domain"));
- MappingImpl domain2Mapping = MappingImpl.domain(Domain.of("domain2"));
+ Mapping addressMapping = Mapping.address("aaa");
+ Mapping errorMapping = Mapping.error("error");
+ Mapping domainMapping = Mapping.domain(Domain.of("domain"));
+ Mapping domain2Mapping = Mapping.domain(Domain.of("domain2"));
MappingsImpl mappingsImpl = MappingsImpl.builder()
.add(domainMapping)
.add(addressMapping)
@@ -329,9 +329,9 @@ public class MappingsImplTest {
@Test
public void builderShouldPutDomainAliasFirstThenForwardWhenVariousMappings() {
- MappingImpl regexMapping = MappingImpl.regex("regex");
- MappingImpl forwardMapping = MappingImpl.forward("forward");
- MappingImpl domainMapping = MappingImpl.domain(Domain.of("domain"));
+ Mapping regexMapping = Mapping.regex("regex");
+ Mapping forwardMapping = Mapping.forward("forward");
+ Mapping domainMapping = Mapping.domain(Domain.of("domain"));
MappingsImpl mappingsImpl = MappingsImpl.builder()
.add(regexMapping)
.add(forwardMapping)
@@ -342,10 +342,10 @@ public class MappingsImplTest {
@Test
public void builderShouldPutGroupsBetweenDomainAndForward() {
- MappingImpl regexMapping = MappingImpl.regex("regex");
- MappingImpl forwardMapping = MappingImpl.forward("forward");
- MappingImpl domainMapping = MappingImpl.domain(Domain.of("domain"));
- MappingImpl groupMapping = MappingImpl.group("group");
+ Mapping regexMapping = Mapping.regex("regex");
+ Mapping forwardMapping = Mapping.forward("forward");
+ Mapping domainMapping = Mapping.domain(Domain.of("domain"));
+ Mapping groupMapping = Mapping.group("group");
MappingsImpl mappingsImpl = MappingsImpl.builder()
.add(regexMapping)
.add(forwardMapping)
---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscribe@james.apache.org
For additional commands, e-mail: server-dev-help@james.apache.org