Support SMS Message Sending

Author: StuartFerguson

MessagingService.BusinessLogic.Tests/RequestHandlers/EmailRequestHandlerTests.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MessagingService.BusinessLogic.Tests.RequestHandlers
+{
+    using System.Threading;
+    using BusinessLogic.RequestHandlers;
+    using BusinessLogic.Requests;
+    using BusinessLogic.Services;
+    using Moq;
+    using Services;
+    using Shouldly;
+    using Testing;
+    using Xunit;
+
+    public class MessagingRequestHandlerTests
+    {
+        [Fact]
+        public void MessagingRequestHandler_SendEmailRequest_IsHandled()
+        {
+            Mock<IMessagingDomainService> messagingDomainService = new Mock<IMessagingDomainService>();
+            MessagingRequestHandler handler = new MessagingRequestHandler(messagingDomainService.Object);
+
+            SendEmailRequest command = TestData.SendEmailRequest;
+
+            Should.NotThrow(async () =>
+                            {
+                                await handler.Handle(command, CancellationToken.None);
+                            });
+
+        }
+
+        [Fact]
+        public void MessagingRequestHandler_SendSMSRequest_IsHandled()
+        {
+            Mock<IMessagingDomainService> messagingDomainService = new Mock<IMessagingDomainService>();
+            MessagingRequestHandler handler = new MessagingRequestHandler(messagingDomainService.Object);
+
+            SendSMSRequest command = TestData.SendSMSRequest;
+
+            Should.NotThrow(async () =>
+                            {
+                                await handler.Handle(command, CancellationToken.None);
+                            });
+
+        }
+    }
+}

MessagingService.BusinessLogic.Tests/RequestHandlers/MessagingRequestHandlerTests.cs

@@ -31,5 +31,22 @@ public void SendEmailRequest_CanBeCreated_IsCreated()
             request.Body.ShouldBe(TestData.Body);
             request.IsHtml.ShouldBe(TestData.IsHtmlTrue);
         }
+
+        [Fact]
+        public void SendSMSRequest_CanBeCreated_IsCreated()
+        {
+            SendSMSRequest request = SendSMSRequest.Create(TestData.ConnectionIdentifier,
+                                                           TestData.MessageId,
+                                                           TestData.Sender,
+                                                           TestData.Destination,
+                                                           TestData.Message);
+
+            request.ShouldNotBeNull();
+            request.ConnectionIdentifier.ShouldBe(TestData.ConnectionIdentifier);
+            request.MessageId.ShouldBe(TestData.MessageId);
+            request.Sender.ShouldBe(TestData.Sender);
+            request.Destination.ShouldBe(TestData.Destination);
+            request.Message.ShouldBe(TestData.Message);
+        }
     }
 }

MessagingService.BusinessLogic.Tests/Requests/RequestTests.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MessagingService.BusinessLogic.Tests.Services
+{
+    using System.Threading;
+    using System.Threading.Tasks;
+    using BusinessLogic.Services;
+    using BusinessLogic.Services.EmailServices;
+    using BusinessLogic.Services.SMSServices;
+    using EmailMessageAggregate;
+    using Moq;
+    using Shared.EventStore.EventStore;
+    using SMSMessageAggregate;
+    using Testing;
+    using Xunit;
+
+    public class MessagingDomainServiceTests
+    {
+        [Fact]
+        public async Task MessagingDomainService_SendEmailMessage_MessageSent()
+        {
+            Mock<IAggregateRepository<EmailAggregate>> emailAggregateRepository = new Mock<IAggregateRepository<EmailAggregate>>();
+            emailAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEmptyEmailAggregate());
+            Mock<IAggregateRepository<SMSAggregate>> smsAggregateRepository = new Mock<IAggregateRepository<SMSAggregate>>();
+            Mock<IEmailServiceProxy> emailServiceProxy = new Mock<IEmailServiceProxy>();
+            emailServiceProxy
+                .Setup(e => e.SendEmail(It.IsAny<Guid>(),
+                                        It.IsAny<String>(),
+                                        It.IsAny<List<String>>(),
+                                        It.IsAny<String>(),
+                                        It.IsAny<String>(),
+                                        It.IsAny<Boolean>(),
+                                        It.IsAny<CancellationToken>())).ReturnsAsync(TestData.SuccessfulEmailServiceProxyResponse);
+            Mock<ISMSServiceProxy> smsServiceProxy = new Mock<ISMSServiceProxy>();
+
+            MessagingDomainService messagingDomainService =
+                new MessagingDomainService(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+
+            await messagingDomainService.SendEmailMessage(TestData.ConnectionIdentifier,
+                                                          TestData.MessageId,
+                                                          TestData.FromAddress,
+                                                          TestData.ToAddresses,
+                                                          TestData.Subject,
+                                                          TestData.Body,
+                                                          TestData.IsHtmlTrue,
+                                                          CancellationToken.None);
+        }
+
+        [Fact]
+        public async Task MessagingDomainService_SendSMSMessage_MessageSent()
+        {
+            Mock<IAggregateRepository<EmailAggregate>> emailAggregateRepository = new Mock<IAggregateRepository<EmailAggregate>>();
+            Mock<IAggregateRepository<SMSAggregate>> smsAggregateRepository = new Mock<IAggregateRepository<SMSAggregate>>();
+            smsAggregateRepository.Setup(a => a.GetLatestVersion(It.IsAny<Guid>(), It.IsAny<CancellationToken>())).ReturnsAsync(TestData.GetEmptySMSAggregate());
+            Mock<IEmailServiceProxy> emailServiceProxy = new Mock<IEmailServiceProxy>();
+            Mock<ISMSServiceProxy> smsServiceProxy = new Mock<ISMSServiceProxy>();
+            smsServiceProxy
+                .Setup(e => e.SendSMS(It.IsAny<Guid>(),
+                                        It.IsAny<String>(),
+                                        It.IsAny<String>(),
+                                        It.IsAny<String>(),
+                                        It.IsAny<CancellationToken>())).ReturnsAsync(TestData.SuccessfulSMSServiceProxyResponse);
+            MessagingDomainService messagingDomainService =
+                new MessagingDomainService(emailAggregateRepository.Object, smsAggregateRepository.Object, emailServiceProxy.Object, smsServiceProxy.Object);
+
+            await messagingDomainService.SendSMSMessage(TestData.ConnectionIdentifier,
+                                                        TestData.MessageId,
+                                                        TestData.Sender,
+                                                        TestData.Destination,
+                                                        TestData.Message,
+                                                        CancellationToken.None);
+        }
+
+    }
+}

MessagingService.BusinessLogic.Tests/Services/EmailDomainServiceTests.cs

@@ -15,6 +15,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\MessagingService.EmailMessageAggregate\MessagingService.EmailMessageAggregate.csproj" />
+    <ProjectReference Include="..\MessagingService.SMSMessageAggregate\MessagingService.SMSMessageAggregate.csproj" />
   </ItemGroup>
 
 </Project>

MessagingService.BusinessLogic.Tests/Services/MessagingDomainServiceTests.cs

@@ -0,0 +1,77 @@
+namespace MessagingService.BusinessLogic.RequestHandlers
+{
+    using System;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using MediatR;
+    using Requests;
+    using Services;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="MediatR.IRequestHandler{MessagingService.BusinessLogic.Requests.SendEmailRequest, System.String}" />
+    public class MessagingRequestHandler : IRequestHandler<SendEmailRequest, String>, IRequestHandler<SendSMSRequest, String>
+    {
+        #region Fields
+
+        /// <summary>
+        /// The messaging domain service
+        /// </summary>
+        private readonly IMessagingDomainService MessagingDomainService;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MessagingRequestHandler" /> class.
+        /// </summary>
+        /// <param name="messagingDomainService">The messaging domain service.</param>
+        public MessagingRequestHandler(IMessagingDomainService messagingDomainService)
+        {
+            this.MessagingDomainService = messagingDomainService;
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Handles a request
+        /// </summary>
+        /// <param name="request">The request</param>
+        /// <param name="cancellationToken">Cancellation token</param>
+        /// <returns>
+        /// Response from the request
+        /// </returns>
+        public async Task<String> Handle(SendEmailRequest request,
+                                         CancellationToken cancellationToken)
+        {
+            await this.MessagingDomainService.SendEmailMessage(request.ConnectionIdentifier,
+                                                               request.MessageId,
+                                                               request.FromAddress,
+                                                               request.ToAddresses,
+                                                               request.Subject,
+                                                               request.Body,
+                                                               request.IsHtml,
+                                                               cancellationToken);
+
+            return string.Empty;
+        }
+
+        public async Task<String> Handle(SendSMSRequest request,
+                                         CancellationToken cancellationToken)
+        {
+            await this.MessagingDomainService.SendSMSMessage(request.ConnectionIdentifier,
+                                                             request.MessageId,
+                                                             request.Sender,
+                                                             request.Destination,
+                                                             request.Message,
+                                                             cancellationToken);
+            return string.Empty;
+        }
+
+        #endregion
+    }
+}