private Stream<Mapping> recurseMapping(Stream<Mapping> nonRecursiveResult, User targetUser, int remainingLoops) throws ErrorMappingException, RecipientRewriteTableException { Mappings childMappings = getMappings(targetUser, remainingLoops - 1); if (childMappings.isEmpty()) { return nonRecursiveResult; } else { return childMappings.asStream(); } }
@Then("retrieving mappings for user \"([^\"]*)\" at domain \"([^\"]*)\" should raise an ErrorMappingException with message \"([^\"]*)\"") public void retrievingMappingsForUserAtDomainShouldRaiseAnException(String user, String domain, String message) throws Exception { assertThatThrownBy(() -> rewriteTable.getMappings(user, Domain.of(domain))) .isInstanceOf(ErrorMappingException.class) .hasMessage(message); } }
@Then("mappings for user \"([^\"]*)\" at domain \"([^\"]*)\" should be empty") public void assertMappingsIsEmpty(String user, String domain) throws Throwable { assertThat(rewriteTable.getMappings(user, Domain.of(domain))).isNullOrEmpty(); }
private Mappings getMappings(User user, int mappingLimit) throws ErrorMappingException, RecipientRewriteTableException { // We have to much mappings throw ErrorMappingException to avoid // infinity loop if (mappingLimit == 0) { throw new TooManyMappingException("554 Too many mappings to process"); } Mappings targetMappings = mapAddress(user.getLocalPart(), user.getDomainPart().get()); try { return MappingsImpl.fromMappings( targetMappings.asStream() .flatMap(Throwing.function((Mapping target) -> convertAndRecurseMapping(user, target, mappingLimit)).sneakyThrow())); } catch (SkipMappingProcessingException e) { return MappingsImpl.empty(); } }
@Then("mappings for user \"([^\"]*)\" at domain \"([^\"]*)\" should contain only \"([^\"]*)\"") public void assertMappingsForUser(String user, String domain, List<String> mappings) throws Throwable { assertThat(rewriteTable.getMappings(user, Domain.of(domain)).asStrings()).containsOnlyElementsOf(mappings); }
@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(); }
@Test public void addForwardMappingShouldStore() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; MappingSource source = MappingSource.fromUser(user, domain); virtualUserTable.addMapping(source, Mapping.forward(address)); virtualUserTable.addMapping(source, Mapping.forward(address2)); assertThat(virtualUserTable.getMappings(user, domain)).hasSize(2); }
@Test public void addGroupMappingShouldStore() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; MappingSource source = MappingSource.fromUser(user, domain); virtualUserTable.addMapping(source, Mapping.group(address)); virtualUserTable.addMapping(source, Mapping.group(address2)); assertThat(virtualUserTable.getMappings(user, domain)).hasSize(2); }
@Test public void testStoreAndRetrieveErrorMapping() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; Domain domain = Domain.LOCALHOST; MappingSource source = MappingSource.fromUser(user, domain); String error = "bounce!"; assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); virtualUserTable.addMapping(source, Mapping.error(error)); assertThat(virtualUserTable.getAllMappings()).describedAs("One mappingline").hasSize(1); assertThatThrownBy(() -> virtualUserTable.getMappings(user, domain)) .describedAs("Exception thrown on to many mappings") .isInstanceOf(ErrorMappingException.class); virtualUserTable.removeMapping(source, Mapping.error(error)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); assertThat(virtualUserTable.getAllMappings()).describedAs("No mapping").isEmpty(); }
@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 public void addMappingShouldNotThrowWhenMappingAlreadyExistsWithAnOtherType() throws Exception { String user = "test"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; MappingSource source = MappingSource.fromUser(user, domain); virtualUserTable.addMapping(source, Mapping.address(address)); virtualUserTable.addMapping(source, Mapping.regex(address)); assertThat(virtualUserTable.getMappings(user, domain)).hasSize(2); }
@Test public void testStoreAndRetrieveAddressMapping() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; Domain domain = Domain.LOCALHOST; MappingSource source = MappingSource.fromUser(user, domain); String address = "test@localhost2"; String address2 = "test@james"; assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); virtualUserTable.addMapping(source, Mapping.address(address)); virtualUserTable.addMapping(source, Mapping.address(address2)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("Two mappings").hasSize(2); assertThat(virtualUserTable.getAllMappings()).describedAs("One mappingline").hasSize(1); virtualUserTable.removeMapping(source, Mapping.address(address)); virtualUserTable.removeMapping(source, Mapping.address(address2)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); assertThat(virtualUserTable.getAllMappings()).describedAs("No mapping").isEmpty(); }
@Test public void testStoreAndRetrieveRegexMapping() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; Domain domain = Domain.LOCALHOST; MappingSource source = MappingSource.fromUser(user, domain); // String regex = "(.*):{$1}@localhost"; // String regex2 = "(.+):{$1}@test"; String regex = "(.*)@localhost"; String regex2 = "(.+)@test"; String invalidRegex = ".*):"; assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); virtualUserTable.addMapping(source, Mapping.regex(regex)); virtualUserTable.addMapping(source, Mapping.regex(regex2)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("Two mappings").hasSize(2); assertThat(virtualUserTable.getAllMappings()).describedAs("One mappingline").hasSize(1); virtualUserTable.removeMapping(source, Mapping.regex(regex)); assertThatThrownBy(() -> virtualUserTable.addRegexMapping(source, invalidRegex)) .describedAs("Invalid Mapping throw exception") .isInstanceOf(RecipientRewriteTableException.class); virtualUserTable.removeMapping(source, Mapping.regex(regex2)); assertThat(virtualUserTable.getMappings(user, domain)).describedAs("No mapping") .isEqualTo(MappingsImpl.empty()); assertThat(virtualUserTable.getAllMappings()).describedAs("No mapping").isEmpty(); }
@Test public void testRecursiveMapping() throws ErrorMappingException, RecipientRewriteTableException { String user1 = "user1"; String user2 = "user2"; String user3 = "user3"; Domain domain1 = Domain.of("domain1"); Domain domain2 = Domain.of("domain2"); Domain domain3 = Domain.of("domain3"); MappingSource source1 = MappingSource.fromUser(user1, domain1); MappingSource source2 = MappingSource.fromUser(user2, domain2); MappingSource source3 = MappingSource.fromUser(user3, domain3); virtualUserTable.setRecursiveMapping(true); assertThat(virtualUserTable.getAllMappings()).describedAs("No mapping").isEmpty(); virtualUserTable.addMapping(source1, Mapping.address(user2 + "@" + domain2.asString())); virtualUserTable.addMapping(source2, Mapping.address(user3 + "@" + domain3.asString())); assertThat(virtualUserTable.getMappings(user1, domain1)).containsOnly(Mapping.address(user3 + "@" + domain3.asString())); virtualUserTable.addMapping(source3, Mapping.address(user1 + "@" + domain1.asString())); assertThatThrownBy(() -> virtualUserTable.getMappings(user1, domain1)) .describedAs("Exception thrown on to many mappings") .isInstanceOf(ErrorMappingException.class); // disable recursive mapping virtualUserTable.setRecursiveMapping(false); assertThat(virtualUserTable.getMappings(user1, domain1)).describedAs("Not recursive mapped").containsExactly(Mapping.address(user2 + "@" + domain2.asString())); }
@Test public void removeForwardMappingShouldDelete() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; MappingSource source = MappingSource.fromUser(user, domain); virtualUserTable.addMapping(source, Mapping.forward(address)); virtualUserTable.addMapping(source, Mapping.forward(address2)); virtualUserTable.removeMapping(source, Mapping.forward(address)); virtualUserTable.removeMapping(source, Mapping.forward(address2)); assertThat(virtualUserTable.getMappings(user, domain)) .isEqualTo(MappingsImpl.empty()); }
@Test public void removeGroupMappingShouldDelete() throws ErrorMappingException, RecipientRewriteTableException { String user = "test"; Domain domain = Domain.LOCALHOST; String address = "test@localhost2"; String address2 = "test@james"; MappingSource source = MappingSource.fromUser(user, domain); virtualUserTable.addMapping(source, Mapping.group(address)); virtualUserTable.addMapping(source, Mapping.group(address2)); virtualUserTable.removeMapping(source, Mapping.group(address)); virtualUserTable.removeMapping(source, Mapping.group(address2)); assertThat(virtualUserTable.getMappings(user, domain)) .isEqualTo(MappingsImpl.empty()); } }
@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))); }