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 rc...@apache.org on 2020/03/17 10:51:13 UTC
[james-project] 03/17: JAMES-3112 distinguish Domain Alias from
Domain Mapping RRTs
This is an automated email from the ASF dual-hosted git repository.
rcordier pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git
commit 81139cd94211358ca6a31b75b56c11b20e894ee4
Author: Benoit Tellier <bt...@linagora.com>
AuthorDate: Tue Mar 10 08:54:20 2020 +0700
JAMES-3112 distinguish Domain Alias from Domain Mapping RRTs
Domain mapping is intended for technical purposes, and should not be
taken into account for user allowed from.
Domain aliases are user exposed, and should be taken into account for
user eallowed from.
---
.../java/org/apache/james/utils/DataProbeImpl.java | 2 +-
.../james/rrt/api/RecipientRewriteTable.java | 11 ++-
.../java/org/apache/james/rrt/lib/Mapping.java | 6 ++
.../rrt/lib/AliasReverseResolverContract.java | 4 +-
.../apache/james/rrt/lib/CanSendFromContract.java | 13 +++-
.../java/org/apache/james/rrt/lib/MappingTest.java | 16 ++++
.../rrt/lib/AbstractRecipientRewriteTable.java | 19 ++++-
.../james/rrt/lib/AliasReverseResolverImpl.java | 2 +-
.../org/apache/james/rrt/lib/CanSendFromImpl.java | 3 +-
.../rrt/lib/RecipientRewriteTableManagement.java | 4 +-
.../rrt/lib/AbstractRecipientRewriteTableTest.java | 10 ++-
.../org/apache/james/rrt/lib/MappingsImplTest.java | 23 +++++-
.../james/rrt/lib/RewriteTablesStepdefs.java | 22 ++++--
.../test/resources/cucumber/rewrite_tables.feature | 85 ++++++++++++++++++----
.../rrt/lib/AliasReverseResolverImplTest.java | 4 +-
.../apache/james/rrt/lib/CanSendFromImplTest.java | 7 +-
.../methods/SetMessagesCreationProcessorTest.java | 2 +-
.../apache/james/smtpserver/SMTPServerTest.java | 2 +-
.../webadmin/routes/DomainMappingsRoutes.java | 4 +-
.../james/webadmin/service/DomainAliasService.java | 6 +-
.../james/webadmin/routes/AliasRoutesTest.java | 5 +-
.../webadmin/routes/DomainMappingsRoutesTest.java | 10 +--
.../james/webadmin/routes/ForwardRoutesTest.java | 5 +-
.../james/webadmin/routes/GroupsRoutesTest.java | 6 +-
.../james/webadmin/routes/MappingRoutesTest.java | 57 +++++++++++++--
25 files changed, 266 insertions(+), 62 deletions(-)
diff --git a/server/container/guice/guice-common/src/main/java/org/apache/james/utils/DataProbeImpl.java b/server/container/guice/guice-common/src/main/java/org/apache/james/utils/DataProbeImpl.java
index 8381e0b..d2f64f5 100644
--- a/server/container/guice/guice-common/src/main/java/org/apache/james/utils/DataProbeImpl.java
+++ b/server/container/guice/guice-common/src/main/java/org/apache/james/utils/DataProbeImpl.java
@@ -120,7 +120,7 @@ public class DataProbeImpl implements GuiceProbe, DataProbe {
@Override
public void addDomainAliasMapping(String aliasDomain, String deliveryDomain) throws Exception {
- recipientRewriteTable.addAliasDomainMapping(MappingSource.fromDomain(Domain.of(aliasDomain)), Domain.of(deliveryDomain));
+ recipientRewriteTable.addDomainAliasMapping(MappingSource.fromDomain(Domain.of(aliasDomain)), Domain.of(deliveryDomain));
}
@Override
diff --git a/server/data/data-api/src/main/java/org/apache/james/rrt/api/RecipientRewriteTable.java b/server/data/data-api/src/main/java/org/apache/james/rrt/api/RecipientRewriteTable.java
index d11d338..be173e9 100644
--- a/server/data/data-api/src/main/java/org/apache/james/rrt/api/RecipientRewriteTable.java
+++ b/server/data/data-api/src/main/java/org/apache/james/rrt/api/RecipientRewriteTable.java
@@ -53,7 +53,8 @@ public interface RecipientRewriteTable {
Mapping.Type.Forward,
Mapping.Type.Address,
Mapping.Type.Alias,
- Mapping.Type.Domain);
+ Mapping.Type.Domain,
+ Mapping.Type.DomainAlias);
void addMapping(MappingSource source, Mapping mapping) throws RecipientRewriteTableException;
@@ -71,9 +72,13 @@ public interface RecipientRewriteTable {
void removeErrorMapping(MappingSource source, String error) throws RecipientRewriteTableException;
- void addAliasDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException;
+ void addDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException;
- void removeAliasDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException;
+ void removeDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException;
+
+ void addDomainAliasMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException;
+
+ void removeDomainAliasMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException;
void addForwardMapping(MappingSource source, String address) throws RecipientRewriteTableException;
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 9630c4d..80fab25 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
@@ -85,6 +85,10 @@ public interface Mapping {
return of(Type.Domain, mapping.asString());
}
+ static Mapping domainAlias(Domain mapping) {
+ return of(Type.DomainAlias, mapping.asString());
+ }
+
static Mapping forward(String mapping) {
return of(Type.Forward, mapping);
}
@@ -117,6 +121,8 @@ public interface Mapping {
MailAddressConversionPolicy.ToEmpty, TypeOrder.TYPE_ORDER_4),
Domain("domain:", new UserRewritter.DomainRewriter(), IdentityMappingPolicy.Throw,
MailAddressConversionPolicy.ToEmpty, TypeOrder.TYPE_ORDER_1),
+ DomainAlias("domainAlias:", new UserRewritter.DomainRewriter(), IdentityMappingPolicy.Throw,
+ MailAddressConversionPolicy.ToEmpty, TypeOrder.TYPE_ORDER_1),
Error("error:", new UserRewritter.ThrowingRewriter(), IdentityMappingPolicy.Throw,
MailAddressConversionPolicy.ToEmpty, TypeOrder.TYPE_ORDER_4),
Forward("forward:", new UserRewritter.ReplaceRewriter(), IdentityMappingPolicy.ReturnIdentity,
diff --git a/server/data/data-api/src/test/java/org/apache/james/rrt/lib/AliasReverseResolverContract.java b/server/data/data-api/src/test/java/org/apache/james/rrt/lib/AliasReverseResolverContract.java
index d0d7f66..84593e4 100644
--- a/server/data/data-api/src/test/java/org/apache/james/rrt/lib/AliasReverseResolverContract.java
+++ b/server/data/data-api/src/test/java/org/apache/james/rrt/lib/AliasReverseResolverContract.java
@@ -43,7 +43,7 @@ public interface AliasReverseResolverContract {
void addAliasMapping(Username alias, Username user) throws Exception;
- void addDomainMapping(Domain alias, Domain domain) throws Exception;
+ void addDomainAlias(Domain alias, Domain domain) throws Exception;
void addGroupMapping(String group, Username user) throws Exception;
@@ -62,7 +62,7 @@ public interface AliasReverseResolverContract {
}
default CanSendFromContract.RequireDomain redirectDomain(Domain alias) {
- return domain -> addDomainMapping(alias, domain);
+ return domain -> addDomainAlias(alias, domain);
}
default CanSendFromContract.RequireUserName redirectGroup(String group) {
diff --git a/server/data/data-api/src/test/java/org/apache/james/rrt/lib/CanSendFromContract.java b/server/data/data-api/src/test/java/org/apache/james/rrt/lib/CanSendFromContract.java
index 5a182ec..7591526 100644
--- a/server/data/data-api/src/test/java/org/apache/james/rrt/lib/CanSendFromContract.java
+++ b/server/data/data-api/src/test/java/org/apache/james/rrt/lib/CanSendFromContract.java
@@ -43,6 +43,8 @@ public interface CanSendFromContract {
void addAliasMapping(Username alias, Username user) throws Exception;
+ void addDomainAlias(Domain alias, Domain domain) throws Exception;
+
void addDomainMapping(Domain alias, Domain domain) throws Exception;
void addGroupMapping(String group, Username user) throws Exception;
@@ -62,7 +64,7 @@ public interface CanSendFromContract {
}
default RequireDomain redirectDomain(Domain alias) {
- return domain -> addDomainMapping(alias, domain);
+ return domain -> addDomainAlias(alias, domain);
}
default RequireUserName redirectGroup(String group) {
@@ -142,6 +144,15 @@ public interface CanSendFromContract {
}
@Test
+ default void userCanSendFromShouldBeFalseWhenDomainMapping() throws Exception {
+ Username fromUser = USER.withOtherDomain(Optional.of(OTHER_DOMAIN));
+
+ addDomainMapping(OTHER_DOMAIN, DOMAIN);
+
+ assertThat(canSendFrom().userCanSendFrom(USER, fromUser)).isFalse();
+ }
+
+ @Test
default void userCanSendFromShouldBeFalseWhenWhenSenderIsAnAliasOfTheUserFromAGroupAlias() throws Exception {
Username fromGroup = Username.of("group@example.com");
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 f500199..0cc4006 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
@@ -188,6 +188,12 @@ public class MappingTest {
}
@Test
+ void domainAliasFactoryMethodShouldThrowOnNull() {
+ assertThatThrownBy(() -> Mapping.domainAlias(null))
+ .isInstanceOf(NullPointerException.class);
+ }
+
+ @Test
void errorFactoryMethodShouldThrowOnNull() {
assertThatThrownBy(() -> Mapping.error(null))
.isInstanceOf(NullPointerException.class);
@@ -272,6 +278,11 @@ public class MappingTest {
}
@Test
+ void getTypeShouldReturnDomainAliasWhenDomainAliasPrefix() {
+ assertThat(Mapping.domainAlias(Domain.of("abc")).getType()).isEqualTo(Type.DomainAlias);
+ }
+
+ @Test
void getTypeShouldReturnForwardWhenForwardPrefix() {
assertThat(Mapping.forward("abc").getType()).isEqualTo(Mapping.Type.Forward);
}
@@ -330,6 +341,11 @@ public class MappingTest {
}
@Test
+ void asMailAddressShouldReturnEmptyForDomainAlias() {
+ assertThat(Mapping.domainAlias(Domain.of("value")).asMailAddress()).isEmpty();
+ }
+
+ @Test
void asMailAddressShouldReturnMappingValueForForward() throws Exception {
assertThat(Mapping.forward("value@domain").asMailAddress())
.contains(new MailAddress("value@domain"));
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 b341d92..b4bcf88 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
@@ -158,6 +158,7 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
return Mapping.of(type, rewrittenUsername.asString());
case Regex:
case Domain:
+ case DomainAlias:
case Error:
case Address:
return Mapping.address(rewrittenUsername.asString());
@@ -242,7 +243,7 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
}
@Override
- public void addAliasDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException {
+ public void addDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException {
checkDomainMappingSourceIsManaged(source);
LOGGER.info("Add domain mapping: {} => {}", source.asDomain().map(Domain::asString).orElse("null"), realDomain);
@@ -250,12 +251,26 @@ public abstract class AbstractRecipientRewriteTable implements RecipientRewriteT
}
@Override
- public void removeAliasDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException {
+ public void removeDomainMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException {
LOGGER.info("Remove domain mapping: {} => {}", source.asDomain().map(Domain::asString).orElse("null"), realDomain);
removeMapping(source, Mapping.domain(realDomain));
}
@Override
+ public void addDomainAliasMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException {
+ checkDomainMappingSourceIsManaged(source);
+
+ LOGGER.info("Add domain alias mapping: {} => {}", source.asDomain().map(Domain::asString).orElse("null"), realDomain);
+ addMapping(source, Mapping.domainAlias(realDomain));
+ }
+
+ @Override
+ public void removeDomainAliasMapping(MappingSource source, Domain realDomain) throws RecipientRewriteTableException {
+ LOGGER.info("Remove domain alias mapping: {} => {}", source.asDomain().map(Domain::asString).orElse("null"), realDomain);
+ removeMapping(source, Mapping.domainAlias(realDomain));
+ }
+
+ @Override
public void addForwardMapping(MappingSource source, String address) throws RecipientRewriteTableException {
Mapping mapping = Mapping.forward(address)
.appendDomainFromThrowingSupplierIfNone(this::defaultDomain);
diff --git a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/AliasReverseResolverImpl.java b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/AliasReverseResolverImpl.java
index d231122..57d2b6d 100644
--- a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/AliasReverseResolverImpl.java
+++ b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/AliasReverseResolverImpl.java
@@ -97,7 +97,7 @@ public class AliasReverseResolverImpl implements AliasReverseResolver {
getMappingLimit(),
Throwing.<Domain, Stream<Domain>>function(targetDomain ->
recipientRewriteTable
- .listSources(Mapping.domain(targetDomain))
+ .listSources(Mapping.domainAlias(targetDomain))
.map(MappingSource::asDomain)
.flatMap(OptionalUtils::toStream)).sneakyThrow()
);
diff --git a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/CanSendFromImpl.java b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/CanSendFromImpl.java
index 70d7a82..e07db8a 100644
--- a/server/data/data-library/src/main/java/org/apache/james/rrt/lib/CanSendFromImpl.java
+++ b/server/data/data-library/src/main/java/org/apache/james/rrt/lib/CanSendFromImpl.java
@@ -20,6 +20,7 @@ package org.apache.james.rrt.lib;
import static org.apache.james.rrt.lib.Mapping.Type.Alias;
import static org.apache.james.rrt.lib.Mapping.Type.Domain;
+import static org.apache.james.rrt.lib.Mapping.Type.DomainAlias;
import java.util.EnumSet;
import java.util.List;
@@ -43,7 +44,7 @@ public class CanSendFromImpl implements CanSendFrom {
List<Domain> fetch(Username user);
}
- public static final EnumSet<Mapping.Type> ALIAS_TYPES_ACCEPTED_IN_FROM = EnumSet.of(Alias, Domain);
+ public static final EnumSet<Mapping.Type> ALIAS_TYPES_ACCEPTED_IN_FROM = EnumSet.of(Alias, DomainAlias);
private final RecipientRewriteTable recipientRewriteTable;
private final AliasReverseResolver aliasReverseResolver;
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 2fb789c..4149d1d 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
@@ -83,13 +83,13 @@ public class RecipientRewriteTableManagement extends StandardMBean implements Re
@Override
public void addDomainMapping(String domain, String targetDomain) throws RecipientRewriteTableException {
MappingSource source = MappingSource.fromDomain(Domain.of(domain));
- rrt.addAliasDomainMapping(source, Domain.of(targetDomain));
+ rrt.addDomainMapping(source, Domain.of(targetDomain));
}
@Override
public void removeDomainMapping(String domain, String targetDomain) throws RecipientRewriteTableException {
MappingSource source = MappingSource.fromDomain(Domain.of(domain));
- rrt.removeAliasDomainMapping(source, Domain.of(targetDomain));
+ rrt.removeDomainMapping(source, Domain.of(targetDomain));
}
@Override
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 4f9928c..c837815 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
@@ -612,8 +612,14 @@ public abstract class AbstractRecipientRewriteTableTest {
}
@Test
- public void addAliasDomainMappingShouldThrowWhenSourceDomainIsNotInDomainList() {
- assertThatThrownBy(() -> virtualUserTable.addAliasDomainMapping(SOURCE_WITH_DOMAIN_NOT_IN_DOMAIN_LIST, SUPPORTED_DOMAIN))
+ public void addDomainMappingShouldThrowWhenSourceDomainIsNotInDomainList() {
+ assertThatThrownBy(() -> virtualUserTable.addDomainMapping(SOURCE_WITH_DOMAIN_NOT_IN_DOMAIN_LIST, SUPPORTED_DOMAIN))
+ .isInstanceOf(SourceDomainIsNotInDomainListException.class);
+ }
+
+ @Test
+ public void addDomainAliasShouldThrowWhenSourceDomainIsNotInDomainList() {
+ assertThatThrownBy(() -> virtualUserTable.addDomainAliasMapping(SOURCE_WITH_DOMAIN_NOT_IN_DOMAIN_LIST, SUPPORTED_DOMAIN))
.isInstanceOf(SourceDomainIsNotInDomainListException.class);
}
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 afae9e2..82bbe19 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
@@ -108,14 +108,18 @@ public class MappingsImplTest {
MappingsImpl actual = MappingsImpl.fromRawString("error:test");
assertThat(actual).containsOnly(Mapping.error("test"));
}
-
@Test
public void fromRawStringShouldNotUseColonDelimiterWhenValueStartsWithDomain() {
MappingsImpl actual = MappingsImpl.fromRawString("domain:test");
assertThat(actual).containsOnly(Mapping.domain(Domain.of("test")));
}
-
+
+ @Test
+ public void fromRawStringShouldNotUseColonDelimiterWhenValueStartsWithDomainAlias() {
+ MappingsImpl actual = MappingsImpl.fromRawString("domainAlias:test");
+ assertThat(actual).containsOnly(Mapping.domainAlias(Domain.of("test")));
+ }
@Test
public void fromRawStringShouldNotUseColonDelimiterWhenValueStartsWithRegex() {
@@ -328,7 +332,7 @@ public class MappingsImplTest {
}
@Test
- public void builderShouldPutDomainAliasFirstThenForwardWhenVariousMappings() {
+ public void builderShouldPutDomainMappingFirstThenForwardWhenVariousMappings() {
Mapping regexMapping = Mapping.regex("regex");
Mapping forwardMapping = Mapping.forward("forward");
Mapping domainMapping = Mapping.domain(Domain.of("domain"));
@@ -341,6 +345,19 @@ public class MappingsImplTest {
}
@Test
+ public void builderShouldPutDomainAliasFirstThenForwardWhenVariousMappings() {
+ Mapping regexMapping = Mapping.regex("regex");
+ Mapping forwardMapping = Mapping.forward("forward");
+ Mapping domainAlias = Mapping.domainAlias(Domain.of("domain"));
+ MappingsImpl mappingsImpl = MappingsImpl.builder()
+ .add(regexMapping)
+ .add(forwardMapping)
+ .add(domainAlias)
+ .build();
+ assertThat(mappingsImpl).containsExactly(domainAlias, forwardMapping, regexMapping);
+ }
+
+ @Test
public void builderShouldPutGroupsBetweenDomainAndForward() {
Mapping regexMapping = Mapping.regex("regex");
Mapping forwardMapping = Mapping.forward("forward");
diff --git a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/RewriteTablesStepdefs.java b/server/data/data-library/src/test/java/org/apache/james/rrt/lib/RewriteTablesStepdefs.java
index dde65e2..ade2238 100644
--- a/server/data/data-library/src/test/java/org/apache/james/rrt/lib/RewriteTablesStepdefs.java
+++ b/server/data/data-library/src/test/java/org/apache/james/rrt/lib/RewriteTablesStepdefs.java
@@ -82,9 +82,14 @@ public class RewriteTablesStepdefs {
storeAddressMappingForUserAtDomain(address, MappingSource.fromDomain(Domain.of(domain)));
}
- @Given("store \"([^\"]*)\" alias domain mapping for domain \"([^\"]*)\"")
- public void storeAliasDomainMappingForDomain(String aliasDomain, String domain) throws Throwable {
- rewriteTable.addAliasDomainMapping(MappingSource.fromDomain(Domain.of(aliasDomain)), Domain.of(domain));
+ @Given("store \"([^\"]*)\" domain mapping for domain \"([^\"]*)\"")
+ public void storeDomainMappingForDomain(String aliasDomain, String domain) throws Throwable {
+ rewriteTable.addDomainMapping(MappingSource.fromDomain(Domain.of(aliasDomain)), Domain.of(domain));
+ }
+
+ @Given("store \"([^\"]*)\" domain alias for domain \"([^\"]*)\"")
+ public void storeDomainAliasMappingForDomain(String aliasDomain, String domain) throws Throwable {
+ rewriteTable.addDomainAliasMapping(MappingSource.fromDomain(Domain.of(aliasDomain)), Domain.of(domain));
}
@Given("store \"([^\"]*)\" forward mapping for user \"([^\"]*)\" at domain \"([^\"]*)\"")
@@ -161,9 +166,14 @@ public class RewriteTablesStepdefs {
userAtDomainRemovesAddressMapping(address, MappingSource.fromDomain(Domain.of(domain)));
}
- @When("alias domain mapping \"([^\"]*)\" for \"([^\"]*)\" domain is removed")
- public void removeAliasDomainMappingForDomain(String aliasdomain, String domain) throws Throwable {
- rewriteTable.removeAliasDomainMapping(MappingSource.fromDomain(Domain.of(aliasdomain)), Domain.of(domain));
+ @When("domain mapping \"([^\"]*)\" for \"([^\"]*)\" domain is removed")
+ public void removeDomainMappingForDomain(String aliasdomain, String domain) throws Throwable {
+ rewriteTable.removeDomainMapping(MappingSource.fromDomain(Domain.of(aliasdomain)), Domain.of(domain));
+ }
+
+ @When("domain alias \"([^\"]*)\" for \"([^\"]*)\" domain is removed")
+ public void removeDomainAliasForDomain(String aliasdomain, String domain) throws Throwable {
+ rewriteTable.removeDomainAliasMapping(MappingSource.fromDomain(Domain.of(aliasdomain)), Domain.of(domain));
}
@Then("mappings should be empty")
diff --git a/server/data/data-library/src/test/resources/cucumber/rewrite_tables.feature b/server/data/data-library/src/test/resources/cucumber/rewrite_tables.feature
index c4367de..b96e217 100644
--- a/server/data/data-library/src/test/resources/cucumber/rewrite_tables.feature
+++ b/server/data/data-library/src/test/resources/cucumber/rewrite_tables.feature
@@ -134,48 +134,93 @@ Feature: Rewrite Tables tests
# Alias mapping
Scenario: address mapping should be retrieved when searching with a domain alias
- Given store "aliasdomain" alias domain mapping for domain "localhost"
+ Given store "aliasdomain" domain mapping for domain "localhost"
Then mappings for user "test" at domain "aliasdomain" should contain only "test@localhost"
Scenario: address mapping should be retrieved when searching with a domain alias
Given store "test2@localhost" address mapping for user "test" at domain "localhost"
- And store "aliasdomain" alias domain mapping for domain "localhost"
+ And store "aliasdomain" domain mapping for domain "localhost"
Then mappings for user "test" at domain "aliasdomain" should contain only "test2@localhost"
Scenario: address mapping should be retrieved when searching with a domain alias (reverse insertion order)
- Given store "aliasdomain" alias domain mapping for domain "localhost"
+ Given store "aliasdomain" domain mapping for domain "localhost"
+ And store "test2@localhost" address mapping for user "test" at domain "localhost"
+ Then mappings for user "test" at domain "aliasdomain" should contain only "test2@localhost"
+
+ Scenario: address mapping should be retrieved when searching with a domain alias
+ Given store "aliasdomain" domain alias for domain "localhost"
+ Then mappings for user "test" at domain "aliasdomain" should contain only "test@localhost"
+
+ Scenario: address mapping should be retrieved when searching with a domain alias
+ Given store "test2@localhost" address mapping for user "test" at domain "localhost"
+ And store "aliasdomain" domain alias for domain "localhost"
+ Then mappings for user "test" at domain "aliasdomain" should contain only "test2@localhost"
+
+ Scenario: address mapping should be retrieved when searching with a domain alias (reverse insertion order)
+ Given store "aliasdomain" domain alias for domain "localhost"
And store "test2@localhost" address mapping for user "test" at domain "localhost"
Then mappings for user "test" at domain "aliasdomain" should contain only "test2@localhost"
Scenario: address mapping should be retrieved when searching with the correct domain and exists an alias domain
Given store "test2@localhost" address mapping for user "test" at domain "localhost"
- And store "aliasdomain" alias domain mapping for domain "localhost"
+ And store "aliasdomain" domain mapping for domain "localhost"
Then mappings for user "test" at domain "localhost" should contain only "test2@localhost"
Scenario: wildcard address mapping should be retrieved when searching with a domain alias
Given store "wildcard@localhost" address mapping as wildcard for domain "localhost"
- And store "aliasdomain" alias domain mapping for domain "localhost"
+ And store "aliasdomain" domain mapping for domain "localhost"
Then mappings for user "test" at domain "aliasdomain" should contain only "wildcard@localhost"
Scenario: wildcard address mapping should be retrieved when searching with a domain and exists an alias domain
Given store "wildcard@localhost" address mapping as wildcard for domain "localhost"
- And store "aliasdomain" alias domain mapping for domain "localhost"
+ And store "aliasdomain" domain mapping for domain "localhost"
Then mappings for user "test" at domain "localhost" should contain only "wildcard@localhost"
Scenario: both wildcard address mapping and default user address should be retrieved when wildcard address mapping on alias domain
Given store "wildcard@localhost" address mapping as wildcard for domain "aliasdomain"
- And store "aliasdomain" alias domain mapping for domain "localhost"
+ And store "aliasdomain" domain mapping for domain "localhost"
Then mappings for user "test" at domain "aliasdomain" should contain only "test@localhost, wildcard@localhost"
Scenario: both wildcard address mapping and default user address should be retrieved when wildcard address mapping on alias domain (reverse insertion order)
- Given store "aliasdomain" alias domain mapping for domain "localhost"
+ Given store "aliasdomain" domain mapping for domain "localhost"
And store "wildcard@localhost" address mapping as wildcard for domain "aliasdomain"
Then mappings for user "test" at domain "aliasdomain" should contain only "test@localhost, wildcard@localhost"
Scenario: asking for a removed domain alias should fail
Given store "wildcard@localhost" address mapping as wildcard for domain "localhost"
- And store "aliasdomain" alias domain mapping for domain "localhost"
- When alias domain mapping "aliasdomain" for "localhost" domain is removed
+ And store "aliasdomain" domain mapping for domain "localhost"
+ When domain mapping "aliasdomain" for "localhost" domain is removed
+ Then mappings for user "test" at domain "aliasdomain" should be empty
+
+ Scenario: address mapping should be retrieved when searching with the correct domain and exists an alias domain
+ Given store "test2@localhost" address mapping for user "test" at domain "localhost"
+ And store "aliasdomain" domain alias for domain "localhost"
+ Then mappings for user "test" at domain "localhost" should contain only "test2@localhost"
+
+ Scenario: wildcard address mapping should be retrieved when searching with a domain alias
+ Given store "wildcard@localhost" address mapping as wildcard for domain "localhost"
+ And store "aliasdomain" domain alias for domain "localhost"
+ Then mappings for user "test" at domain "aliasdomain" should contain only "wildcard@localhost"
+
+ Scenario: wildcard address mapping should be retrieved when searching with a domain and exists an alias domain
+ Given store "wildcard@localhost" address mapping as wildcard for domain "localhost"
+ And store "aliasdomain" domain alias for domain "localhost"
+ Then mappings for user "test" at domain "localhost" should contain only "wildcard@localhost"
+
+ Scenario: both wildcard address mapping and default user address should be retrieved when wildcard address mapping on alias domain
+ Given store "wildcard@localhost" address mapping as wildcard for domain "aliasdomain"
+ And store "aliasdomain" domain alias for domain "localhost"
+ Then mappings for user "test" at domain "aliasdomain" should contain only "test@localhost, wildcard@localhost"
+
+ Scenario: both wildcard address mapping and default user address should be retrieved when wildcard address mapping on alias domain (reverse insertion order)
+ Given store "aliasdomain" domain alias for domain "localhost"
+ And store "wildcard@localhost" address mapping as wildcard for domain "aliasdomain"
+ Then mappings for user "test" at domain "aliasdomain" should contain only "test@localhost, wildcard@localhost"
+
+ Scenario: asking for a removed domain alias should fail
+ Given store "wildcard@localhost" address mapping as wildcard for domain "localhost"
+ And store "aliasdomain" domain alias for domain "localhost"
+ When domain alias "aliasdomain" for "localhost" domain is removed
Then mappings for user "test" at domain "aliasdomain" should be empty
# Mixed mapping
@@ -183,7 +228,13 @@ Feature: Rewrite Tables tests
Scenario: mixed mapping should work
Given store "test2@localhost" address mapping for user "test" at domain "localhost"
And store "(.*)@localhost:user@localhost" regexp mapping for user "test" at domain "localhost"
- And store "aliasdomain" alias domain mapping for domain "localhost"
+ And store "aliasdomain" domain mapping for domain "localhost"
+ Then mappings for user "test" at domain "localhost" should contain only "test2@localhost, user@localhost"
+
+ Scenario: mixed mapping should work
+ Given store "test2@localhost" address mapping for user "test" at domain "localhost"
+ And store "(.*)@localhost:user@localhost" regexp mapping for user "test" at domain "localhost"
+ And store "aliasdomain" domain alias for domain "localhost"
Then mappings for user "test" at domain "localhost" should contain only "test2@localhost, user@localhost"
# Recursive mapping
@@ -223,9 +274,15 @@ Feature: Rewrite Tables tests
Then mappings for user "user1" at domain "domain1" should contain only "user2@domain2"
Scenario: recursive mapping should work when three levels on alias domains
- Given store "domain2" alias domain mapping for domain "domain1"
- And store "domain3" alias domain mapping for domain "domain2"
- And store "domain4" alias domain mapping for domain "domain3"
+ Given store "domain2" domain mapping for domain "domain1"
+ And store "domain3" domain mapping for domain "domain2"
+ And store "domain4" domain mapping for domain "domain3"
+ Then mappings for user "test" at domain "domain4" should contain only "test@domain1"
+
+ Scenario: recursive mapping should work when three levels on alias domains
+ Given store "domain2" domain alias for domain "domain1"
+ And store "domain3" domain alias for domain "domain2"
+ And store "domain4" domain alias for domain "domain3"
Then mappings for user "test" at domain "domain4" should contain only "test@domain1"
# Forward mapping
diff --git a/server/data/data-memory/src/test/java/org/apache/james/rrt/lib/AliasReverseResolverImplTest.java b/server/data/data-memory/src/test/java/org/apache/james/rrt/lib/AliasReverseResolverImplTest.java
index 12bf887..35e7cda 100644
--- a/server/data/data-memory/src/test/java/org/apache/james/rrt/lib/AliasReverseResolverImplTest.java
+++ b/server/data/data-memory/src/test/java/org/apache/james/rrt/lib/AliasReverseResolverImplTest.java
@@ -64,8 +64,8 @@ public class AliasReverseResolverImplTest implements AliasReverseResolverContrac
}
@Override
- public void addDomainMapping(Domain alias, Domain domain) throws Exception {
- recipientRewriteTable.addAliasDomainMapping(MappingSource.fromDomain(alias), domain);
+ public void addDomainAlias(Domain alias, Domain domain) throws Exception {
+ recipientRewriteTable.addDomainAliasMapping(MappingSource.fromDomain(alias), domain);
}
@Override
diff --git a/server/data/data-memory/src/test/java/org/apache/james/rrt/lib/CanSendFromImplTest.java b/server/data/data-memory/src/test/java/org/apache/james/rrt/lib/CanSendFromImplTest.java
index f846f67..e5161bd 100644
--- a/server/data/data-memory/src/test/java/org/apache/james/rrt/lib/CanSendFromImplTest.java
+++ b/server/data/data-memory/src/test/java/org/apache/james/rrt/lib/CanSendFromImplTest.java
@@ -65,8 +65,13 @@ public class CanSendFromImplTest implements CanSendFromContract {
}
@Override
+ public void addDomainAlias(Domain alias, Domain domain) throws Exception {
+ recipientRewriteTable.addDomainAliasMapping(MappingSource.fromDomain(alias), domain);
+ }
+
+ @Override
public void addDomainMapping(Domain alias, Domain domain) throws Exception {
- recipientRewriteTable.addAliasDomainMapping(MappingSource.fromDomain(alias), domain);
+ recipientRewriteTable.addDomainMapping(MappingSource.fromDomain(alias), domain);
}
@Override
diff --git a/server/protocols/jmap-draft/src/test/java/org/apache/james/jmap/draft/methods/SetMessagesCreationProcessorTest.java b/server/protocols/jmap-draft/src/test/java/org/apache/james/jmap/draft/methods/SetMessagesCreationProcessorTest.java
index 196e5e7..06d8979 100644
--- a/server/protocols/jmap-draft/src/test/java/org/apache/james/jmap/draft/methods/SetMessagesCreationProcessorTest.java
+++ b/server/protocols/jmap-draft/src/test/java/org/apache/james/jmap/draft/methods/SetMessagesCreationProcessorTest.java
@@ -466,7 +466,7 @@ public class SetMessagesCreationProcessorTest {
.email("user@other.org")
.build();
- recipientRewriteTable.addMapping(MappingSource.fromDomain(Domain.of("other.org")), Mapping.domain(Domain.of("example.com")));
+ recipientRewriteTable.addMapping(MappingSource.fromDomain(Domain.of("other.org")), Mapping.domainAlias(Domain.of("example.com")));
assertThatCode(() -> sut.assertUserCanSendFrom(USER, Optional.of(sender)))
.doesNotThrowAnyException();
diff --git a/server/protocols/protocols-smtp/src/test/java/org/apache/james/smtpserver/SMTPServerTest.java b/server/protocols/protocols-smtp/src/test/java/org/apache/james/smtpserver/SMTPServerTest.java
index e3ae55e..6e4eec9 100644
--- a/server/protocols/protocols-smtp/src/test/java/org/apache/james/smtpserver/SMTPServerTest.java
+++ b/server/protocols/protocols-smtp/src/test/java/org/apache/james/smtpserver/SMTPServerTest.java
@@ -1460,7 +1460,7 @@ public class SMTPServerTest {
String sender = "test_user_smtp@examplebis.local";
usersRepository.addUser(Username.of(userName), "pwd");
- rewriteTable.addAliasDomainMapping(MappingSource.fromDomain(Domain.of("examplebis.local")), Domain.of(LOCAL_DOMAIN));
+ rewriteTable.addDomainAliasMapping(MappingSource.fromDomain(Domain.of("examplebis.local")), Domain.of(LOCAL_DOMAIN));
smtpProtocol.sendCommand("AUTH PLAIN");
smtpProtocol.sendCommand(Base64.getEncoder().encodeToString(("\0" + userName + "\0pwd\0").getBytes(UTF_8)));
diff --git a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/DomainMappingsRoutes.java b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/DomainMappingsRoutes.java
index 55ec507..6fc88f0 100644
--- a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/DomainMappingsRoutes.java
+++ b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/routes/DomainMappingsRoutes.java
@@ -114,7 +114,7 @@ public class DomainMappingsRoutes implements Routes {
private void addAliasDomainMapping(MappingSource source, Domain destinationDomain) throws RecipientRewriteTableException {
try {
- recipientRewriteTable.addAliasDomainMapping(source, destinationDomain);
+ recipientRewriteTable.addDomainAliasMapping(source, destinationDomain);
} catch (SourceDomainIsNotInDomainListException e) {
throw ErrorResponder.builder()
.statusCode(HttpStatus.BAD_REQUEST_400)
@@ -140,7 +140,7 @@ public class DomainMappingsRoutes implements Routes {
MappingSource mappingSource = mappingSourceFrom(request);
Domain destinationDomain = extractDomain(request.body());
- recipientRewriteTable.removeAliasDomainMapping(mappingSource, destinationDomain);
+ recipientRewriteTable.removeDomainMapping(mappingSource, destinationDomain);
return halt(HttpStatus.NO_CONTENT_204);
}
diff --git a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/DomainAliasService.java b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/DomainAliasService.java
index bc8e10d..8a1c7df 100644
--- a/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/DomainAliasService.java
+++ b/server/protocols/webadmin/webadmin-data/src/main/java/org/apache/james/webadmin/service/DomainAliasService.java
@@ -70,14 +70,14 @@ public class DomainAliasService {
}
public ImmutableSet<DomainAliasResponse> listDomainAliases(Domain domain) throws RecipientRewriteTableException {
- return recipientRewriteTable.listSources(Mapping.domain(domain))
+ return recipientRewriteTable.listSources(Mapping.domainAlias(domain))
.map(DomainAliasResponse::new)
.collect(Guavate.toImmutableSet());
}
public boolean hasAliases(Domain domain) throws DomainListException, RecipientRewriteTableException {
return domainList.containsDomain(domain)
- || recipientRewriteTable.listSources(Mapping.domain(domain)).findFirst().isPresent();
+ || recipientRewriteTable.listSources(Mapping.domainAlias(domain)).findFirst().isPresent();
}
public void addDomainAlias(Domain sourceDomain, Domain destinationDomain) throws DomainListException, RecipientRewriteTableException {
@@ -94,7 +94,7 @@ public class DomainAliasService {
}
checkSameSourceAndDestination(sourceDomain, destinationDomain);
- operation.perform(MappingSource.fromDomain(sourceDomain), Mapping.domain(destinationDomain));
+ operation.perform(MappingSource.fromDomain(sourceDomain), Mapping.domainAlias(destinationDomain));
}
private void checkSameSourceAndDestination(Domain source, Domain destination) throws RecipientRewriteTableException {
diff --git a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/AliasRoutesTest.java b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/AliasRoutesTest.java
index 2ef976e..2d29cfd 100644
--- a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/AliasRoutesTest.java
+++ b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/AliasRoutesTest.java
@@ -66,6 +66,7 @@ class AliasRoutesTest {
private static final Domain DOMAIN = Domain.of("b.com");
private static final Domain ALIAS_DOMAIN = Domain.of("alias");
+ private static final Domain DOMAIN_MAPPING = Domain.of("mapping");
public static final String BOB = "bob@" + DOMAIN.name();
public static final String BOB_WITH_SLASH = "bob/@" + DOMAIN.name();
public static final String BOB_WITH_ENCODED_SLASH = "bob%2F@" + DOMAIN.name();
@@ -113,6 +114,7 @@ class AliasRoutesTest {
.autoDetectIp(false));
domainList.addDomain(DOMAIN);
domainList.addDomain(ALIAS_DOMAIN);
+ domainList.addDomain(DOMAIN_MAPPING);
MappingSourceModule module = new MappingSourceModule();
memoryRecipientRewriteTable.setDomainList(domainList);
@@ -406,7 +408,8 @@ class AliasRoutesTest {
super.setUp();
memoryRecipientRewriteTable.addErrorMapping(MappingSource.fromUser("error", DOMAIN), "disabled");
memoryRecipientRewriteTable.addRegexMapping(MappingSource.fromUser("regex", DOMAIN), ".*@b\\.com");
- memoryRecipientRewriteTable.addAliasDomainMapping(MappingSource.fromDomain(ALIAS_DOMAIN), DOMAIN);
+ memoryRecipientRewriteTable.addDomainAliasMapping(MappingSource.fromDomain(ALIAS_DOMAIN), DOMAIN);
+ memoryRecipientRewriteTable.addDomainMapping(MappingSource.fromDomain(DOMAIN_MAPPING), DOMAIN);
}
}
diff --git a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/DomainMappingsRoutesTest.java b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/DomainMappingsRoutesTest.java
index d8b1b6e..072c7a0 100644
--- a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/DomainMappingsRoutesTest.java
+++ b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/DomainMappingsRoutesTest.java
@@ -154,9 +154,9 @@ class DomainMappingsRoutesTest {
Domain expectedDomain = Domain.of("abc.com");
MappingSource mappingSource = MappingSource.fromDomain(expectedDomain);
- recipientRewriteTable.addAliasDomainMapping(mappingSource, Domain.of(alias1));
- recipientRewriteTable.addAliasDomainMapping(mappingSource, Domain.of(alias2));
- recipientRewriteTable.addAliasDomainMapping(mappingSource, Domain.of(alias3));
+ recipientRewriteTable.addDomainMapping(mappingSource, Domain.of(alias1));
+ recipientRewriteTable.addDomainMapping(mappingSource, Domain.of(alias2));
+ recipientRewriteTable.addDomainMapping(mappingSource, Domain.of(alias3));
Map<String, List<String>> map =
when()
@@ -245,7 +245,7 @@ class DomainMappingsRoutesTest {
MappingSource mappingSource = MappingSource.fromDomain(Domain.of("from.com"));
String alias = "to.com";
- recipientRewriteTable.addAliasDomainMapping(mappingSource, Domain.of(alias));
+ recipientRewriteTable.addDomainMapping(mappingSource, Domain.of(alias));
Assumptions.assumeTrue(recipientRewriteTable.getStoredMappings(mappingSource) != null);
@@ -301,7 +301,7 @@ class DomainMappingsRoutesTest {
recipientRewriteTable.addGroupMapping(mappingSource, "user@domain.com");
recipientRewriteTable.addForwardMapping(mappingSource, "user@domain.com");
recipientRewriteTable.addErrorMapping(mappingSource, "disabled");
- recipientRewriteTable.addAliasDomainMapping(mappingSource, Domain.of(aliasDomain));
+ recipientRewriteTable.addDomainMapping(mappingSource, Domain.of(aliasDomain));
List<String> body =
when()
diff --git a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/ForwardRoutesTest.java b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/ForwardRoutesTest.java
index 27c8ec9..bcecf27 100644
--- a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/ForwardRoutesTest.java
+++ b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/ForwardRoutesTest.java
@@ -68,6 +68,7 @@ class ForwardRoutesTest {
private static final Domain DOMAIN = Domain.of("b.com");
private static final Domain ALIAS_DOMAIN = Domain.of("alias");
+ private static final Domain DOMAIN_MAPPING = Domain.of("mapping");
public static final String CEDRIC = "cedric@" + DOMAIN.name();
public static final String ALICE = "alice@" + DOMAIN.name();
public static final String ALICE_WITH_SLASH = "alice/@" + DOMAIN.name();
@@ -112,6 +113,7 @@ class ForwardRoutesTest {
.autoDetectIp(false));
domainList.addDomain(DOMAIN);
domainList.addDomain(ALIAS_DOMAIN);
+ domainList.addDomain(DOMAIN_MAPPING);
memoryRecipientRewriteTable.setDomainList(domainList);
MappingSourceModule mappingSourceModule = new MappingSourceModule();
@@ -436,7 +438,8 @@ class ForwardRoutesTest {
super.setUp();
memoryRecipientRewriteTable.addErrorMapping(MappingSource.fromUser("error", DOMAIN), "disabled");
memoryRecipientRewriteTable.addRegexMapping(MappingSource.fromUser("regex", DOMAIN), ".*@b\\.com");
- memoryRecipientRewriteTable.addAliasDomainMapping(MappingSource.fromDomain(ALIAS_DOMAIN), DOMAIN);
+ memoryRecipientRewriteTable.addDomainMapping(MappingSource.fromDomain(DOMAIN_MAPPING), DOMAIN);
+ memoryRecipientRewriteTable.addDomainAliasMapping(MappingSource.fromDomain(ALIAS_DOMAIN), DOMAIN);
}
}
diff --git a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/GroupsRoutesTest.java b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/GroupsRoutesTest.java
index 6c2f9c7..bd68fcd 100644
--- a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/GroupsRoutesTest.java
+++ b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/GroupsRoutesTest.java
@@ -65,6 +65,7 @@ import io.restassured.http.ContentType;
class GroupsRoutesTest {
private static final Domain DOMAIN = Domain.of("b.com");
+ private static final Domain DOMAIN_MAPPING = Domain.of("mapping");
private static final Domain ALIAS_DOMAIN = Domain.of("alias");
private static final String GROUP1 = "group1" + "@" + DOMAIN.name();
private static final String GROUP2 = "group2" + "@" + DOMAIN.name();
@@ -106,6 +107,7 @@ class GroupsRoutesTest {
domainList = new MemoryDomainList(dnsService);
domainList.addDomain(DOMAIN);
domainList.addDomain(ALIAS_DOMAIN);
+ domainList.addDomain(DOMAIN_MAPPING);
memoryRecipientRewriteTable.setDomainList(domainList);
usersRepository = MemoryUsersRepository.withVirtualHosting(domainList);
MappingSourceModule mappingSourceModule = new MappingSourceModule();
@@ -427,8 +429,8 @@ class GroupsRoutesTest {
super.setUp();
memoryRecipientRewriteTable.addErrorMapping(MappingSource.fromUser("error", DOMAIN), "disabled");
memoryRecipientRewriteTable.addRegexMapping(MappingSource.fromUser("regex", DOMAIN), ".*@b\\.com");
- memoryRecipientRewriteTable.addAliasDomainMapping(MappingSource.fromDomain(ALIAS_DOMAIN), DOMAIN);
-
+ memoryRecipientRewriteTable.addDomainMapping(MappingSource.fromDomain(DOMAIN_MAPPING), DOMAIN);
+ memoryRecipientRewriteTable.addDomainAliasMapping(MappingSource.fromDomain(ALIAS_DOMAIN), DOMAIN);
}
}
diff --git a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/MappingRoutesTest.java b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/MappingRoutesTest.java
index 22b4e93..01fb052 100644
--- a/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/MappingRoutesTest.java
+++ b/server/protocols/webadmin/webadmin-data/src/test/java/org/apache/james/webadmin/routes/MappingRoutesTest.java
@@ -69,6 +69,7 @@ class MappingRoutesTest {
DomainList domainList = new MemoryDomainList(dnsService);
domainList.addDomain(Domain.of("domain.tld"));
domainList.addDomain(Domain.of("aliasdomain.tld"));
+ domainList.addDomain(Domain.of("domain.mapping.tld"));
domainList.addDomain(Domain.of("abc"));
domainList.addDomain(Domain.of("xyz"));
@@ -135,13 +136,13 @@ class MappingRoutesTest {
}
@Test
- void getMappingsShouldReturnAliasDomainMappings() throws RecipientRewriteTableException {
+ void getMappingsShouldReturnDomainMappings() throws RecipientRewriteTableException {
Domain domain = Domain.of("aliasdomain.tld");
- recipientRewriteTable.addAliasDomainMapping(
+ recipientRewriteTable.addDomainMapping(
MappingSource.fromDomain(domain),
Domain.of("domain1abc.tld"));
- recipientRewriteTable.addAliasDomainMapping(
+ recipientRewriteTable.addDomainMapping(
MappingSource.fromDomain(domain),
Domain.of("domain2cde.tld"));
@@ -171,6 +172,42 @@ class MappingRoutesTest {
}
@Test
+ void getMappingsShouldReturnDomainAliases() throws RecipientRewriteTableException {
+ Domain domain = Domain.of("aliasdomain.tld");
+
+ recipientRewriteTable.addDomainAliasMapping(
+ MappingSource.fromDomain(domain),
+ Domain.of("domain1abc.tld"));
+ recipientRewriteTable.addDomainAliasMapping(
+ MappingSource.fromDomain(domain),
+ Domain.of("domain2cde.tld"));
+
+ String jsonBody = when()
+ .get()
+ .then()
+ .contentType(ContentType.JSON)
+ .statusCode(HttpStatus.OK_200)
+ .extract()
+ .body()
+ .asString();
+
+ assertThatJson(jsonBody)
+ .when(Option.IGNORING_ARRAY_ORDER)
+ .isEqualTo("{" +
+ " \"aliasdomain.tld\" : [" +
+ " {" +
+ " \"type\": \"DomainAlias\"," +
+ " \"mapping\": \"domain1abc.tld\"" +
+ " }," +
+ " {" +
+ " \"type\": \"DomainAlias\"," +
+ " \"mapping\" : \"domain2cde.tld\"" +
+ " }" +
+ " ]" +
+ "}");
+ }
+
+ @Test
void getMappingsShouldReturnAddressMappings() throws Exception {
MailAddress mailAddress = new MailAddress("group@domain.tld");
@@ -348,7 +385,11 @@ class MappingRoutesTest {
MappingSource.fromUser(Username.of("alias@domain.tld")),
"user@domain.tld");
- recipientRewriteTable.addAliasDomainMapping(
+ recipientRewriteTable.addDomainMapping(
+ MappingSource.fromDomain(Domain.of("domain.mapping.tld")),
+ Domain.of("realdomain.tld"));
+
+ recipientRewriteTable.addDomainAliasMapping(
MappingSource.fromDomain(Domain.of("aliasdomain.tld")),
Domain.of("realdomain.tld"));
@@ -386,12 +427,18 @@ class MappingRoutesTest {
" \"mapping\": \"user@domain.tld\"" +
" }" +
" ]," +
- " \"aliasdomain.tld\": [" +
+ " \"domain.mapping.tld\": [" +
" {" +
" \"type\": \"Domain\"," +
" \"mapping\": \"realdomain.tld\"" +
" }" +
" ]," +
+ " \"aliasdomain.tld\": [" +
+ " {" +
+ " \"type\": \"DomainAlias\"," +
+ " \"mapping\": \"realdomain.tld\"" +
+ " }" +
+ " ]," +
" \"address@domain.tld\": [" +
" {" +
" \"type\": \"Address\"," +
---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscribe@james.apache.org
For additional commands, e-mail: server-dev-help@james.apache.org