/** * Returns the real recipient given a virtual username and domain. * * @param user * the virtual user * @param domain * the virtual domain * @return the real recipient address, or <code>null</code> if no mapping * exists */ public static String getTargetString(String user, Domain domain, Map<MappingSource, String> mappings) { return OptionalUtils.or( Optional.ofNullable(mappings.get(MappingSource.fromUser(user, domain))), Optional.ofNullable(mappings.get(MappingSource.fromDomain(domain)))) .orElse(null); }
@Override public void addDomainMapping(String domain, String targetDomain) throws RecipientRewriteTableException { MappingSource source = MappingSource.fromDomain(Domain.of(domain)); rrt.addAliasDomainMapping(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)); }
@Override public void addDomainAliasMapping(String aliasDomain, String deliveryDomain) throws Exception { recipientRewriteTable.addAliasDomainMapping(MappingSource.fromDomain(Domain.of(aliasDomain)), Domain.of(deliveryDomain)); }
@Override protected Mappings mapAddress(String user, Domain domain) { return OptionalUtils.orSuppliers( () -> retrieveMappings(MappingSource.fromUser(user, domain)), () -> retrieveMappings(MappingSource.fromDomain(domain))) .orElse(MappingsImpl.empty()); }
@Override protected Mappings mapAddress(String user, Domain domain) { return OptionalUtils.orSuppliers( () -> retrieveMappings(MappingSource.fromUser(User.fromLocalPartWithDomain(user, domain))), () -> retrieveMappings(MappingSource.fromDomain(domain))) .orElse(MappingsImpl.empty()); }
@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)); }
@Test public void testStoreAndGetMappings() throws ErrorMappingException, RecipientRewriteTableException { Domain domain = Domain.of("test"); virtualUserTable.addMapping(MappingSource.fromDomain(domain), Mapping.regex("prefix_.*:admin@test")); assertThat(virtualUserTable.getMappings("prefix_abc", domain)).isNotEmpty(); }
@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)); }
@Test public void testAliasDomainMapping() throws ErrorMappingException, RecipientRewriteTableException { String domain = "realdomain"; Domain aliasDomain = Domain.of("aliasdomain"); String user = "user"; String user2 = "user2"; assertThat(virtualUserTable.getAllMappings()).describedAs("No mappings").isEmpty(); virtualUserTable.addMapping(MappingSource.fromDomain(aliasDomain), Mapping.address(user2 + "@" + domain)); virtualUserTable.addMapping(MappingSource.fromDomain(aliasDomain), Mapping.domain(Domain.of(domain))); assertThat(virtualUserTable.getMappings(user, aliasDomain)) .describedAs("Domain mapped as first, Address mapped as second") .isEqualTo(MappingsImpl.builder() .add(Mapping.address(user + "@" + domain)) .add(Mapping.address(user2 + "@" + domain)) .build()); virtualUserTable.removeMapping(MappingSource.fromDomain(aliasDomain), Mapping.address(user2 + "@" + domain)); virtualUserTable.removeMapping(MappingSource.fromDomain(aliasDomain), Mapping.domain(Domain.of(domain))); }
@Test void getDomainMappingsEmptyMappingsAreFilteredOut() throws RecipientRewriteTableException { MappingSource nonEmptyMapping = MappingSource.fromDomain(Domain.of("abc.com")); MappingSource emptyMapping = MappingSource.fromDomain(Domain.of("def.com")); Map<MappingSource, Mappings> mappings = ImmutableMap.of( nonEmptyMapping, MappingsImpl.fromRawString("domain:a.com"), emptyMapping, MappingsImpl.empty() ); when(recipientRewriteTable.getAllMappings()).thenReturn(mappings); Map<String, List<String>> map = when() .get() .then() .contentType(ContentType.JSON) .statusCode(HttpStatus.OK_200) .extract() .body() .jsonPath() .getMap("."); assertThat(map) .containsKey(nonEmptyMapping.asString()) .doesNotContainKey(emptyMapping.asString()); }
@BeforeEach void setup() throws Exception { super.setUp(); memoryRecipientRewriteTable.addErrorMapping(MappingSource.fromUser("error", DOMAIN), "disabled"); memoryRecipientRewriteTable.addRegexMapping(MappingSource.fromUser("regex", DOMAIN), ".*@b\\.com"); memoryRecipientRewriteTable.addAliasDomainMapping(MappingSource.fromDomain(Domain.of("alias")), DOMAIN); }
@BeforeEach void setup() throws Exception { super.setUp(); memoryRecipientRewriteTable.addErrorMapping(MappingSource.fromUser("error", DOMAIN), "disabled"); memoryRecipientRewriteTable.addRegexMapping(MappingSource.fromUser("regex", DOMAIN), ".*@b\\.com"); memoryRecipientRewriteTable.addAliasDomainMapping(MappingSource.fromDomain(Domain.of("alias")), DOMAIN); }
@Test public void testStoreAndRetrieveWildCardAddressMapping() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; String user2 = "test2"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; MappingSource source = MappingSource.fromUser(user, domain); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); virtualUserTable.addMapping(MappingSource.fromDomain(domain), Mapping.address(address)); virtualUserTable.addMapping(source, 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(source, Mapping.address(address2)); virtualUserTable.removeMapping(MappingSource.fromDomain(domain), Mapping.address(address)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); assertThat(virtualUserTable.getMappings(user2, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); }
@Test void getDomainMappingsShouldFilterNonDomainMappings() throws RecipientRewriteTableException { MappingSource mappingSource = MappingSource.fromDomain(Domain.of("abc.com")); String address = "addr@domain.com"; recipientRewriteTable.addAddressMapping(mappingSource, address); recipientRewriteTable.addForwardMapping(mappingSource, address); recipientRewriteTable.addErrorMapping(mappingSource, address); recipientRewriteTable.addGroupMapping(mappingSource, address); recipientRewriteTable.addRegexMapping(mappingSource, address); when() .get() .then() .contentType(ContentType.JSON) .statusCode(HttpStatus.OK_200) .body(is("{}")); }
@Test void deleteDomainMappingShouldRemoveMapping() throws RecipientRewriteTableException { MappingSource mappingSource = MappingSource.fromDomain(Domain.of("from.com")); String alias = "to.com"; recipientRewriteTable.addAliasDomainMapping(mappingSource, Domain.of(alias)); Assumptions.assumeTrue(recipientRewriteTable.getUserDomainMappings(mappingSource) != null); given() .body("to.com") .when() .delete("from.com") .then() .body(isEmptyString()); assertThat(recipientRewriteTable.getAllMappings()).isEmpty(); }
@Test void getGroupShouldReturnNotFoundWhenNonGroupMappings() { memoryRecipientRewriteTable.addMapping( MappingSource.fromDomain(DOMAIN), Mapping.domain(Domain.of("target.tld"))); Map<String, Object> errors = when() .get(GROUP1) .then() .statusCode(HttpStatus.NOT_FOUND_404) .contentType(ContentType.JSON) .extract() .body() .jsonPath() .getMap("."); assertThat(errors) .containsEntry("statusCode", HttpStatus.NOT_FOUND_404) .containsEntry("type", "InvalidArgument") .containsEntry("message", "The group does not exist"); }
@Test void getDomainMappingsShouldReturnAllDomainMappings() throws RecipientRewriteTableException { String alias1 = "to_1.com"; String alias2 = "to_2.com"; String alias3 = "to_3.com"; 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)); Map<String, List<String>> map = when() .get() .then() .contentType(ContentType.JSON) .statusCode(HttpStatus.OK_200) .extract() .body() .jsonPath() .getMap("."); assertThat(map) .containsOnly(entry(expectedDomain.name(), ImmutableList.of(alias1, alias2, alias3))); }
@Test void getForwardShouldReturnNotFoundWhenNonForwardMappings() { memoryRecipientRewriteTable.addMapping( MappingSource.fromDomain(DOMAIN), Mapping.domain(Domain.of("target.tld"))); Map<String, Object> errors = when() .get(ALICE) .then() .statusCode(HttpStatus.NOT_FOUND_404) .contentType(ContentType.JSON) .extract() .body() .jsonPath() .getMap("."); assertThat(errors) .containsEntry("statusCode", HttpStatus.NOT_FOUND_404) .containsEntry("type", "InvalidArgument") .containsEntry("message", "The forward does not exist"); }
@Test void getSpecificDomainMappingShouldFilterOutNonDomainMappings() throws RecipientRewriteTableException { String domain = "from.com"; String aliasDomain = "to.com"; final MappingSource mappingSource = MappingSource.fromDomain(Domain.of(domain)); recipientRewriteTable.addRegexMapping(mappingSource, "(.*)@localhost"); recipientRewriteTable.addGroupMapping(mappingSource, "user@domain.com"); recipientRewriteTable.addForwardMapping(mappingSource, "user@domain.com"); recipientRewriteTable.addErrorMapping(mappingSource, "disabled"); recipientRewriteTable.addAliasDomainMapping(mappingSource, Domain.of(aliasDomain)); List<String> body = when() .get(domain) .then() .contentType(ContentType.JSON) .statusCode(HttpStatus.OK_200) .extract() .jsonPath() .getList("."); assertThat(body).containsOnly(aliasDomain); }