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 <matth...@apache.org> Authored: Wed Apr 18 11:08:01 2018 +0200 Committer: Matthieu Baechler <matth...@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-unsubscr...@james.apache.org For additional commands, e-mail: server-dev-h...@james.apache.org