CTA_Form.cs

using System.ComponentModel.DataAnnotations;
using System.Net.Mail;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.DependencyInjection;
using Our.Umbraco.Test.Examples.Support;
using Umbraco.Cms.Core.Cache;
using Umbraco.Cms.Core.DependencyInjection;
using Umbraco.Cms.Core.Logging;
using Umbraco.Cms.Core.Routing;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Web;
using Umbraco.Cms.Infrastructure.Persistence;
using Umbraco.Cms.Tests.Common.Testing;
using Umbraco.Cms.Tests.Integration.Testing;
using Umbraco.Cms.Web.Website.ActionResults;
using Umbraco.Cms.Web.Website.Controllers;
using Umbraco.Extensions;

namespace Our.Umbraco.Test.Examples.SurfaceControllers
{
    [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
    public class CTA_Form : UmbracoIntegrationTestWithContent
    {
        private readonly CtaFormModel validModel = new()
        {
            Name = "E.X. Ample",
            Email = "user@example.com"
        };

        private readonly CtaFormModel invalidModel = new();
        
        private CtaFormController controller = null!;

        [Test]
        public async Task Redirects_To_Current_Page_With_Success_Querystring_For_Valid_Model()
        {
            controller.PrepareModelState(validModel);

            var result = await controller.PostForm(validModel);

            Assert.That(
                result, 
                Is.InstanceOf<RedirectToUmbracoPageResult>() &
                Has.Property(nameof(RedirectToUmbracoPageResult.Key)).EqualTo(Textpage.Key)
            );
        }

        [Test]
        public async Task Sends_Mail_For_Valid_Model()
        {
            controller.PrepareModelState(validModel);
            
            await controller.PostForm(validModel);

            var file = GetRequiredService<SmtpClient>().Last()!;
            await VerifyFile(file).ScrubLinesContaining("Date:");
        }

        [Test]
        public async Task Returns_Current_Page_For_Invalid_Model()
        {
            controller.PrepareModelState(invalidModel);

            var result = await controller.PostForm(invalidModel);

            Assert.That(result, Is.InstanceOf<UmbracoPageResult>());
        }

        [Test]
        public async Task Does_Not_Send_Mail_For_Invalid_Model()
        {
            controller.PrepareModelState(invalidModel);
            
            await controller.PostForm(invalidModel);
            
            var file = GetRequiredService<SmtpClient>().Last()!;
            Assert.That(file, Is.Null);
        }

        [SetUp]
        public void SetupRequest()
        {
            ContentService.SaveAndPublish(Textpage);

            var address = "https://localhost";

            var httpContext = TestHelper.GetHttpContextAccessor().HttpContext!;
            httpContext.PrepareUrl(address);

            var ctx = GetRequiredService<IUmbracoContextFactory>().EnsureUmbracoContext();
            var publishedContent = ctx.UmbracoContext.Content!.GetById(Textpage.Id);

            httpContext.PreparePublishedRequest(ctx, address, publishedContent);

            controller = GetRequiredService<CtaFormController>();
            controller.ControllerContext.HttpContext = httpContext;
        }

        protected override void CustomTestSetup(IUmbracoBuilder builder)
        {
            builder.AddNuCache();
        }

        protected override void ConfigureTestServices(IServiceCollection services)
        {
            services.AddTestSmtpClient();

            services.AddTransient<CtaFormController>();
        }

        [TearDown]
        public void Cleanup()
        {
            GetRequiredService<SmtpClient>().Dispose();
        }
    }

    public class CtaFormController : SurfaceController
    {
        private readonly SmtpClient smtpClient;

        public CtaFormController(
            SmtpClient smtpClient,
            IUmbracoContextAccessor umbracoContextAccessor, 
            IUmbracoDatabaseFactory databaseFactory, 
            ServiceContext services, 
            AppCaches appCaches, 
            IProfilingLogger profilingLogger, 
            IPublishedUrlProvider publishedUrlProvider
        ) : base(umbracoContextAccessor, databaseFactory, services, appCaches, profilingLogger, publishedUrlProvider)
        {
            this.smtpClient = smtpClient;
        }

        public async Task<IActionResult> PostForm(CtaFormModel model)
        {
            if (!ModelState.IsValid)
            {
                return CurrentUmbracoPage();
            }

            var msg = new MailMessage("me@example.com", "you@example.com", "Hello", $"{model.Name} sent a request.")
            {
                ReplyToList = { model.Email }
            };

            await smtpClient.SendMailAsync(msg);
            return RedirectToCurrentUmbracoPage(new QueryString("?success=true"));
        }
    }

    public class CtaFormModel
    {
        [Required]
        public string Name { get; set; } = "";

        [Required]
        [EmailAddress]
        public string Email { get; set; } = "";
    }
}