feature: Allow specific domains to be ignored for sending emails

Author: jhartmann123

src/Directory.Build.props

@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <Version>10.0.1</Version>
+    <Version>10.1.0</Version>
     <TargetFramework>net10.0</TargetFramework>
   </PropertyGroup>
 

src/Email/src/AssemblyInfo.cs

@@ -0,0 +1,6 @@
+// Copyright (c) Fusonic GmbH. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license information.
+
+using System.Runtime.CompilerServices;
+
+[assembly:InternalsVisibleTo("Fusonic.Extensions.Email.Tests")]

src/Email/src/EmailOptions.cs

@@ -69,6 +69,27 @@ public class EmailOptions
     /// </summary>
     public Func<BlazorPostProcessContext, ValueTask<string>>? BlazorContentPostProcessor { get; set; } = static ctx => ValueTask.FromResult(CssInliner.Inline(ctx.Html));
 
+    private static readonly string[] DefaultIgnoredDomains = ["invalid"];
+
+    /// <summary>
+    /// Ignores domains when sending emails. The domain "invalid" always gets ignored, as it may cause bounces and may impact the sender score.
+    /// </summary>
+    /// <remarks>
+    /// As per <a href="https://datatracker.ietf.org/doc/html/rfc6761">RFC6761</a> the domain ".invalid" is reserved and should result in negative responses.
+    /// The domain ".invalid" is the only domain that MAY be recognized by applications AND should cause a negative response.
+    /// This is not the case for other testing domains like ".test" or "example.com", which is why they are not on the default ignore list.
+    /// </remarks>
+    public IReadOnlyList<string> IgnoredDomains { get; set; } = DefaultIgnoredDomains;
+
+    internal IReadOnlyList<string> IgnoredDomainsCleaned => field ??=
+        IgnoredDomains
+            .Select(d => d.ToLowerInvariant().Trim())
+            .Union(DefaultIgnoredDomains)
+            .Distinct()
+            .Select(d => d.StartsWith(".", StringComparison.OrdinalIgnoreCase) ? d : "." + d)
+            .ToList()
+            .AsReadOnly();
+
     internal void Validate()
     {
         var errors = new List<string>();

src/Email/src/SendEmail.cs

@@ -3,6 +3,7 @@
 
 using System.Globalization;
 using Fusonic.Extensions.Mediator;
+using Microsoft.Extensions.Logging;
 using MimeKit;
 
 namespace Fusonic.Extensions.Email;
@@ -33,12 +34,18 @@ public record SendEmail(
     string? ReplyTo = null) : ICommand
 {
     [OutOfBand]
-    public class Handler(EmailOptions emailOptions, ISmtpClient smtpClient, IEnumerable<IEmailRenderingService> emailRenderingServices, IEnumerable<IEmailAttachmentResolver> emailAttachmentResolvers) : AsyncRequestHandler<SendEmail>, IAsyncDisposable
+    public class Handler(EmailOptions emailOptions, ISmtpClient smtpClient, IEnumerable<IEmailRenderingService> emailRenderingServices, IEnumerable<IEmailAttachmentResolver> emailAttachmentResolvers, ILogger<SendEmail> logger) : AsyncRequestHandler<SendEmail>, IAsyncDisposable
     {
         private readonly List<Stream> openedStreams = [];
 
         protected override async Task Handle(SendEmail request, CancellationToken cancellationToken)
         {
+            if (ShouldIgnore(request.Recipient))
+            { 
+                logger.LogInformation("Email of type {Type} to {Recipient} ignored. The domain is on the ignore list.", request.ViewModel?.GetType()?.Name, request.Recipient);
+                return;
+            }
+
             var emailRenderingService = GetRenderingService(request.ViewModel);
 
             var (subject, body) = await emailRenderingService.RenderAsync(request.ViewModel, request.Culture, request.SubjectKey, request.SubjectFormatParameters);
@@ -54,7 +61,7 @@ protected override async Task Handle(SendEmail request, CancellationToken cancel
                 Subject = subject
             };
 
-            if (!string.IsNullOrWhiteSpace(request.BccRecipient))
+            if (!string.IsNullOrWhiteSpace(request.BccRecipient) && !ShouldIgnore(request.BccRecipient))
             {
                 message.Bcc.Add(new MailboxAddress(request.BccRecipient, request.BccRecipient));
             }
@@ -115,6 +122,12 @@ private async Task<MimeEntity> GetMessageBody(string htmlBody, Attachment[]? att
             return builder.ToMessageBody();
         }
 
+        private bool ShouldIgnore(string recipient)
+        {
+            var domain = "." + recipient.Split('@').Last();
+            return emailOptions.IgnoredDomainsCleaned.Any(c => domain.EndsWith(c, StringComparison.OrdinalIgnoreCase));
+        }
+
         private IEmailRenderingService GetRenderingService(object viewModel)
             => emailRenderingServices.FirstOrDefault(r => r.Supports(viewModel))
             ?? throw new InvalidOperationException("No email rendering service registered for view model.");

src/Email/test/EmailOptionsTests.cs

@@ -0,0 +1,80 @@
+// Copyright (c) Fusonic GmbH. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license information.
+
+using System.ComponentModel.DataAnnotations;
+
+namespace Fusonic.Extensions.Email.Tests;
+
+public class EmailOptionsTests
+{
+    [Fact]
+    public void IgnoredDomainsCleaned_NormalizesConfiguredDomainsAndIncludesInvalid()
+    {
+        // Arrange
+        var options = new EmailOptions
+        {
+            IgnoredDomains = [" example.com ", ".Sub.Domain", "EXAMPLE.COM"]
+        };
+
+        // Act
+        var ignoredDomains = options.IgnoredDomainsCleaned;
+
+        // Assert
+        ignoredDomains.Should().BeEquivalentTo([".example.com", ".sub.domain", ".invalid"], o => o.WithStrictOrdering());
+    }
+
+    [Fact]
+    public void Validate_ValidSmtpOptions_DoesNotThrow()
+    {
+        // Arrange
+        var options = new EmailOptions
+        {
+            SenderAddress = "sender@fusonic.net",
+            SenderName = "Fusonic",
+            SmtpServer = "smtp.fusonic.net",
+            SmtpPort = 25
+        };
+
+        // Act
+        var act = () => options.Validate();
+
+        // Assert
+        act.Should().NotThrow();
+    }
+
+    [Fact]
+    public void Validate_StoreInDirectorySet_DoesNotRequireSmtpSettings()
+    {
+        // Arrange
+        var options = new EmailOptions
+        {
+            SenderAddress = "sender@fusonic.net",
+            SenderName = "Fusonic",
+            StoreInDirectory = "c:\\emails",
+            SmtpPort = 0
+        };
+
+        // Act
+        var act = () => options.Validate();
+
+        // Assert
+        act.Should().NotThrow();
+    }
+
+    [Fact]
+    public void Validate_InvalidOptions_ThrowsValidationExceptionWithAllMessages()
+    {
+        // Arrange
+        var options = new EmailOptions
+        {
+            SmtpPort = 0
+        };
+
+        // Act
+        var act = () => options.Validate();
+
+        // Assert
+        act.Should().Throw<ValidationException>()
+           .Which.Message.Should().ContainAll("SenderAddress is required.", "SmtpServer is required.", "SMTP port is invalid.");
+    }
+}

src/Email/test/SendEmailTests.cs

@@ -16,11 +16,15 @@ public partial class SendEmailTests(SendEmailTests.SendEmailFixture fixture) : T
     [Fact]
     public async Task SendEmail_Razor()
     {
+        // Arrange
         Fixture.SmtpServer!.ClearReceivedEmail();
 
         var model = new SendEmailTestEmailViewModel { SomeField = "Some field." };
+
+        // Act
         await SendAsync(new SendEmail("recipient@fusonic.net", "The Recipient", new CultureInfo("de-AT"), model));
 
+        // Assert
         Fixture.SmtpServer.ReceivedEmailCount.Should().Be(1);
         var email = Fixture.SmtpServer.ReceivedEmail.Single();
         email.ToAddresses
@@ -44,11 +48,15 @@ public async Task SendEmail_Razor()
     [Fact]
     public async Task SendEmail_Blazor()
     {
+        // Arrange
         Fixture.SmtpServer!.ClearReceivedEmail();
 
         var model = new SendEmailTestEmailComponentModel { SomeField = "Some field." };
+
+        // Act
         await SendAsync(new SendEmail("recipient@fusonic.net", "The Recipient", new CultureInfo("de-AT"), model));
 
+        // Assert
         Fixture.SmtpServer.ReceivedEmailCount.Should().Be(1);
         var email = Fixture.SmtpServer.ReceivedEmail.Single();
         email.ToAddresses
@@ -71,11 +79,15 @@ public async Task SendEmail_Blazor()
     [Fact]
     public async Task SendEmail_BccAdded()
     {
+        // Arrange
         Fixture.SmtpServer!.ClearReceivedEmail();
 
         var model = new SendEmailTestEmailViewModel { SomeField = "Some field." };
+
+        // Act
         await SendAsync(new SendEmail("recipient@fusonic.net", "The Recipient", new CultureInfo("de-AT"), model, BccRecipient: "bcc@fusonic.net"));
 
+        // Assert
         Fixture.SmtpServer.ReceivedEmailCount.Should().Be(1);
         var email = Fixture.SmtpServer.ReceivedEmail.Single();
         email.ToAddresses.Select(a => a.Address).Should().BeEquivalentTo(["recipient@fusonic.net"]);
@@ -100,6 +112,7 @@ public async Task SendEmail_BccAdded()
     [InlineData("!even-More.xml")]
     public async Task SendEmail_AttachmentsAdded(string attachmentName)
     {
+        // Arrange
         var attachmentPath = Path.Combine(Path.GetDirectoryName(typeof(TestFixture).Assembly.Location)!, "email.css");
         Fixture.SmtpServer!.ClearReceivedEmail();
 
@@ -112,8 +125,10 @@ public async Task SendEmail_AttachmentsAdded(string attachmentName)
             )
         };
 
+        // Act
         await SendAsync(new SendEmail("recipient@fusonic.net", "The Recipient", new CultureInfo("de-AT"), model, Attachments: attachments));
 
+        // Assert
         Fixture.SmtpServer.ReceivedEmailCount.Should().Be(1);
         var email = Fixture.SmtpServer.ReceivedEmail.Single();
         email.MessageParts.Should().HaveCount(2);
@@ -128,18 +143,22 @@ public async Task SendEmail_AttachmentsAdded(string attachmentName)
             email.MessageParts[1].HeaderData.Should().Contain(attachmentName);
         }
 
-        var expectedAttachmentContent = await File.ReadAllTextAsync(attachmentPath, TestContext.Current.CancellationToken); 
+        var expectedAttachmentContent = await File.ReadAllTextAsync(attachmentPath, TestContext.Current.CancellationToken);
         email.MessageParts[1].BodyData.Should().Be(expectedAttachmentContent);
     }
 
     [Fact]
     public async Task SendEmail_HeadersAdded()
     {
+        // Arrange
         Fixture.SmtpServer!.ClearReceivedEmail();
 
         var model = new SendEmailTestEmailViewModel { SomeField = "Some field." };
+
+        // Act
         await SendAsync(new SendEmail("recipient@fusonic.net", "The Recipient", new CultureInfo("de-AT"), model, Headers: new Dictionary<string, string> { ["my-header"] = "value" }));
 
+        // Assert
         Fixture.SmtpServer.ReceivedEmailCount.Should().Be(1);
         var email = Fixture.SmtpServer.ReceivedEmail.Single();
 
@@ -150,15 +169,19 @@ public async Task SendEmail_HeadersAdded()
     [Fact]
     public async Task SendEmail_DefaultHeadersAdded()
     {
+        // Arrange
         Fixture.SmtpServer!.ClearReceivedEmail();
 
         var options = GetInstance<EmailOptions>();
 
         options.DefaultHeaders = new Dictionary<string, string> { ["my-header"] = "value" };
 
         var model = new SendEmailTestEmailViewModel { SomeField = "Some field." };
+
+        // Act
         await SendAsync(new SendEmail("recipient@fusonic.net", "The Recipient", new CultureInfo("de-AT"), model));
 
+        // Assert
         Fixture.SmtpServer.ReceivedEmailCount.Should().Be(1);
         var email = Fixture.SmtpServer.ReceivedEmail.Single();
 
@@ -169,15 +192,19 @@ public async Task SendEmail_DefaultHeadersAdded()
     [Fact]
     public async Task SendEmail_DefaultHeadersOverriddenIfSetTwice()
     {
+        // Arrange
         Fixture.SmtpServer!.ClearReceivedEmail();
 
         var options = GetInstance<EmailOptions>();
 
         options.DefaultHeaders = new Dictionary<string, string> { ["replaced"] = "value", ["default"] = "value" };
 
         var model = new SendEmailTestEmailViewModel { SomeField = "Some field." };
+
+        // Act
         await SendAsync(new SendEmail("recipient@fusonic.net", "The Recipient", new CultureInfo("de-AT"), model, Headers: new Dictionary<string, string> { ["replaced"] = "new-value" }));
 
+        // Assert
         Fixture.SmtpServer.ReceivedEmailCount.Should().Be(1);
         var email = Fixture.SmtpServer.ReceivedEmail.Single();
 
@@ -190,11 +217,15 @@ public async Task SendEmail_DefaultHeadersOverriddenIfSetTwice()
     [Fact]
     public async Task SendEmail_ReplyToAdded()
     {
+        // Arrange
         Fixture.SmtpServer!.ClearReceivedEmail();
 
         var model = new SendEmailTestEmailViewModel { SomeField = "Some field." };
+
+        // Act
         await SendAsync(new SendEmail("recipient@fusonic.net", "The Recipient", new CultureInfo("de-AT"), model, ReplyTo: "reply@mail.com"));
 
+        // Assert
         Fixture.SmtpServer.ReceivedEmailCount.Should().Be(1);
         var email = Fixture.SmtpServer.ReceivedEmail.Single();
 
@@ -205,39 +236,69 @@ public async Task SendEmail_ReplyToAdded()
     [Fact]
     public async Task SendEmail_InvalidBccEmailAddress_ThrowsException()
     {
+        // Arrange
         var model = new SendEmailTestEmailViewModel { SomeField = "Some field." };
 
+        // Act
         var act = async () => await SendAsync(new SendEmail("recipient@fusonic.net", "The Recipient", new CultureInfo("de-AT"), model, BccRecipient: "invalidEmailAddress"));
 
+        // Assert
         await act.Should().ThrowAsync<SmtpCommandException>();
     }
 
     [Fact]
     public async Task SendEmail_UnsupportedAttachmentUri_ThrowsException()
     {
+        // Arrange
         var model = new SendEmailTestEmailViewModel { SomeField = "Some field." };
 
+        // Act
         var act = async () => await SendAsync(new SendEmail("recipient@fusonic.net", "The Recipient", new CultureInfo("de-AT"), model, Attachments: [
             new Attachment("foo", new Uri("soso://over.there/file.txt"))
         ]));
 
+        // Assert
         await act.Should().ThrowAsync<InvalidOperationException>();
     }
 
     [Fact]
     public async Task SendEmail_SubjectFormatParameters_GetPassedToRenderer()
     {
+        // Arrange
         Fixture.SmtpServer!.ClearReceivedEmail();
         var model = new SendEmailTestEmailViewModel { SomeField = "Some field." };
 
         var formatParams = new object[] { 1, "Test" };
+
+        // Act
         await SendAsync(new SendEmail("recipient@fusonic.net", "The Recipient", new CultureInfo("de-AT"), model, SubjectKey: "SubjectFormat", SubjectFormatParameters: formatParams));
 
+        // Assert
         Fixture.SmtpServer.ReceivedEmailCount.Should().Be(1);
         var email = Fixture.SmtpServer.ReceivedEmail.Single();
         email.Subject.Should().Be("The formatted subject 1 Test");
     }
 
+    [Theory]
+    [InlineData("user@test.invalid")]
+    [InlineData("user@sub.domain.invalid")]
+    [InlineData("user@invalid")]
+    [InlineData("invalid")]
+    [InlineData("user@SUB.DOMAIN.INVAlid")]
+    [InlineData("user@DoMaIn.InValid")]
+    public async Task SendEmail_IgnoredDomain_DoesNotSendEmail(string recipient)
+    {
+        // Arrange
+        Fixture.SmtpServer!.ClearReceivedEmail();
+        var model = new SendEmailTestEmailViewModel { SomeField = "Some field." };
+
+        // Act
+        await SendAsync(new SendEmail(recipient, recipient, new CultureInfo("de-AT"), model));
+
+        // Assert
+        Fixture.SmtpServer.ReceivedEmailCount.Should().Be(0);
+    }
+
     public class SendEmailFixture : TestFixture
     {
         public SimpleSmtpServer? SmtpServer { get; private set; }