public async Task Test_SendEmail_ByTemplate()
{
_smtpServer.ClearReceivedEmail();
var emailTemplateProviderMoq = new Mock <IEmailTemplateProvider>();
emailTemplateProviderMoq.Setup(e => e.GetTemplate(It.IsAny <string>())).ReturnsAsync(new EmailTemplate("Duy")
{
ToEmails = "[DuyEmail],{HBDEmail},[email protected]",
Body = "Hello [Name]",
});
using (var mailService = new SmtpEmailService(
new MailMessageProvider(emailTemplateProviderMoq.Object, new TransformerService()), new SmtpEmailOptions
{
FromEmailAddress = new MailAddress("*****@*****.**"),
SmtpClientFactory = () => new SmtpClient("localhost", 25)
}))
{
await mailService.SendAsync("Duy", new object[]
{
new
{
DuyEmail = "*****@*****.**",
HBDEmail = "*****@*****.**",
Name = "Duy Hoang"
}
});
}
_smtpServer.ReceivedEmailCount.Should().BeGreaterOrEqualTo(1);
}
public async Task SendSyncAndAsyncPerformance()
{
// In this sample:
// With 100,000 messages and 10 MaxNumOfSmtpClients async is about twice as fast as sync.
var recipients = new List <Recipient>();
for (var i = 0; i < 1000; i++)
{
recipients.Add(new Recipient()
{
Email = $"recipient-{i}@example.com", Name = $"Name of {i}"
});
}
var mmm = new MailMergeMessage("Async/Sync email test", "This is the plain text part for {Name} ({Email})")
{
Config = _settings.MessageConfig
};
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "{Name}", "{Email}"));
var mms = new MailMergeSender {
Config = _settings.SenderConfig
};
mms.Config.MaxNumOfSmtpClients = 10;
var sw = new Stopwatch();
sw.Start();
mms.Send(mmm, recipients);
sw.Stop();
Console.WriteLine($"Time to send {recipients.Count} messages sync: {sw.ElapsedMilliseconds} milliseconds.");
Console.WriteLine();
Assert.AreEqual(recipients.Count, _server.ReceivedEmail.Length);
Assert.IsFalse(mms.IsBusy);
sw.Reset();
_server.ClearReceivedEmail();
sw.Start();
int numOfSmtpClientsUsed = 0;
mms.OnMergeComplete += (s, args) => { numOfSmtpClientsUsed = args.NumOfSmtpClientsUsed; };
await mms.SendAsync(mmm, recipients);
sw.Stop();
Console.WriteLine($"Time to send {recipients.Count} messages async: {sw.ElapsedMilliseconds} milliseconds.");
// Note: With too many SmtpClients and small emails some of the clients will never de-queue from the ConcurrentQueue of MailMergeSender
Console.WriteLine($"{numOfSmtpClientsUsed} tasks (and SmtpClients) used for sending async\n(max {mms.Config.MaxNumOfSmtpClients} were configured).");
Assert.AreEqual(recipients.Count, _server.ReceivedEmail.Length);
Assert.IsFalse(mms.IsBusy);
}
public void When_SendEmailWithoutSslOrAuth_Expect_EmailSent_Win()
{
server.ClearReceivedEmail();
var os = WinApp.CreateObjectSpace();
var Parameters = os.CreateObject <TestEmailParameters>();
Parameters.To = "*****@*****.**";
Parameters.Body = "Hello";
Parameters.From = "*****@*****.**";
Parameters.SmtpEmailAccount = os.FindObject <SmtpEmailAccount>(new BinaryOperator(nameof(SmtpEmailAccount.Name), AccountNamePort25));
SmtpEmailAccountController.SendEmailSilently(Parameters);
Assert.AreEqual(server.ReceivedEmailCount, 1);
}
public override void InputThread()
{
while (!InputThreadQuitRequested())
{
System.Threading.Thread.Sleep(TimeSpan.FromMilliseconds(100));
if (_smtpServer.ReceivedEmailCount > 0)
{
foreach (SmtpMessage message in _smtpServer.ReceivedEmail)
{
byte[] bytes = Encoding.UTF8.GetBytes(message.Body);
MemoryStream ms = new MemoryStream(bytes);
using (ILogEventParserInstance context = Parser.Begin(ms))
{
LogEvent logEvent = CreateLogEvent();
if (context.ReadNext(logEvent))
{
foreach (string header in message.Headers.AllKeys)
{
logEvent[header] = message.Headers[header];
}
EventReceived(logEvent);
}
}
}
_smtpServer.ClearReceivedEmail();
}
}
}
public async Task Should_Send_Email_Async()
{
// Arrange
_server.ClearReceivedEmail();
EmailSender emailSender = CreateEmailSender();
var expectedRecipient = "*****@*****.**";
var expectedSubject = "Expected subject";
var expectedBody = "Expected body";
var emailMessage = new EmailMessage(new string[] { expectedRecipient }, expectedSubject, expectedBody, null);
// Act
await emailSender.SendEmailAsync(
emailMessage);
// Assert
_server.ReceivedEmailCount.Should().Be(1);
SmtpMessage receivedMail = _server.ReceivedEmail.First();
receivedMail.MessageParts[0].BodyData.Should().Be(expectedBody);
receivedMail.ToAddresses.First().Address.Should().Be(expectedRecipient);
receivedMail.Headers.Get("Subject").Should().Be(expectedSubject);
}
static void Main(string[] args)
{
SimpleSmtpServer server = SimpleSmtpServer.Start();
while (true)
{
if (server.ReceivedEmailCount > 0)
{
foreach (SmtpMessage message in server.ReceivedEmail)
{
Console.WriteLine("----------------------------------------------------------------");
Console.WriteLine();
Console.WriteLine(message.ToString());
}
server.ClearReceivedEmail();
}
Thread.Sleep(100);
}
}
public void SendMessagesWithCarriageReturn()
{
String bodyWithCR = "\n\nKeep these pesky carriage returns\n\nPlease,\nPlease\n\n";
System.Web.Mail.SmtpMail.SmtpServer = "localhost";
SmtpMessage.CR = "\n";
System.Web.Mail.SmtpMail.Send("*****@*****.**", "*****@*****.**", "CRTest", bodyWithCR);
Assert.AreEqual(1, server.ReceivedEmail.Length, "server.ReceivedEmail.Length");
Assert.AreEqual(1, server.ReceivedEmailCount, "server.ReceivedEmailSize");
SmtpMessage email = server.ReceivedEmail[0];
Assert.AreEqual("<*****@*****.**>", email.Headers["To"]);
Assert.AreEqual("<*****@*****.**>", email.Headers["From"]);
Assert.AreEqual("CRTest", email.Headers["Subject"]);
Assert.AreEqual("text/plain;", email.Headers["Content-Type"]);
Assert.AreEqual(bodyWithCR, email.Body, "Body with CR");
server.ClearReceivedEmail();
String bodyWithCRLF = "\r\n\r\nKeep these pesky carriage returns\r\n\r\nPlease,\r\nPlease\r\n\r\n";
SmtpMessage.CR = "\r\n";
System.Web.Mail.SmtpMail.Send("*****@*****.**", "*****@*****.**", "CRTest", bodyWithCRLF);
Assert.AreEqual(1, server.ReceivedEmail.Length, "server.ReceivedEmail.Length");
Assert.AreEqual(1, server.ReceivedEmailCount, "server.ReceivedEmailSize");
email = server.ReceivedEmail[0];
Assert.AreEqual("<*****@*****.**>", email.Headers["To"]);
Assert.AreEqual("<*****@*****.**>", email.Headers["From"]);
Assert.AreEqual("CRTest", email.Headers["Subject"]);
Assert.AreEqual("text/plain;", email.Headers["Content-Type"]);
Assert.AreEqual(bodyWithCRLF, email.Body, "Body with CRLF");
}
// fixture
public EmailServiceTests()
{
var port = (new Random()).Next(50000, 60000);
var emailSettings = new EmailSettings()
{
Host = "localhost",
Port = port, //25 standard, 465 ssl
Authenticate = false
};
var envMock = new Mock <IHostingEnvironment>();
_emailService = new EmailService(emailSettings, envMock.Object);
_smtpServer = SimpleSmtpServer.Start(port);
_smtpServer.ClearReceivedEmail();
// integration test
//var emailMock = new Mock<IEmailService>(MockBehavior.Strict);
////emailMock.Setup(x => x.SendEmailAsync(It.IsAny<EmailMessage>(), CancellationToken.None))
//// .Returns(Task.CompletedTask);
//_emailService = emailMock.Object;
}
public void SetUp()
{
_Server.ClearReceivedEmail();
}
[TestCase(false, true)] // no exception with null for MimeMessage must throw exception
public void Send_With_And_Without_MailMergeMessageException(bool throwException, bool setMimeMessageToNull)
{
#region * Sync and Async preparation *
const string theFormatError = "{causeFormatError}";
const string plainText = theFormatError + "This is the plain text part for {Name} ({Email})";
var mms = new MailMergeSender {
Config = _settings.SenderConfig
};
mms.Config.MaxNumOfSmtpClients = 1;
// Event raising when getting the merged MimeMessage of the MailMergeMessage has failed.
mms.OnMessageFailure += (mailMergeSender, messageFailureArgs) =>
{
lock (_locker)
{
if (throwException)
{
return;
}
// Remove the cause of the exception and return corrected values
// Note: changes of MailMergeMessage will affect als messages to be sent
messageFailureArgs.MailMergeMessage.PlainText = plainText.Replace(theFormatError, string.Empty);
// in production a try...catch... must be implemented
if (setMimeMessageToNull)
{
messageFailureArgs.MimeMessage = null;
}
else
{
messageFailureArgs.MimeMessage =
messageFailureArgs.MailMergeMessage.GetMimeMessage(messageFailureArgs.DataSource);
}
messageFailureArgs.ThrowException = throwException;
}
};
var recipients = new List <Recipient>();
for (var i = 0; i < 2; i++)
{
recipients.Add(new Recipient {
Email = $"recipient-{i}@example.com", Name = $"Name of {i}"
});
}
var mmm = new MailMergeMessage("Message failure", plainText)
{
Config = _settings.MessageConfig
};
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "{Name}", "{Email}"));
#endregion
#region * Synchronous send methods *
// send enumerable data
mmm.PlainText = plainText; // set text from constant
try
{
if (throwException)
{
Assert.Throws <MailMergeMessage.MailMergeMessageException>(() => mms.Send(mmm, recipients));
}
else
{
if (setMimeMessageToNull)
{
Assert.Throws <MailMergeMessage.MailMergeMessageException>(() => mms.Send(mmm, recipients));
}
else
{
Assert.DoesNotThrow(() => mms.Send(mmm, recipients));
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
if (throwException)
{
Assert.AreEqual(0, _server.ReceivedEmailCount);
}
else
{
if (setMimeMessageToNull)
{
Assert.AreEqual(0, _server.ReceivedEmailCount);
}
else
{
Assert.AreEqual(recipients.Count, _server.ReceivedEmailCount);
}
}
_server.ClearReceivedEmail();
// send single data item
mmm.PlainText = plainText; // set text from constant
try
{
if (throwException)
{
Assert.Throws <MailMergeMessage.MailMergeMessageException>(() => mms.Send(mmm, recipients[0]));
}
else
{
if (setMimeMessageToNull)
{
Assert.Throws <MailMergeMessage.MailMergeMessageException>(() => mms.Send(mmm, recipients[0]));
}
else
{
Assert.DoesNotThrow(() => mms.Send(mmm, recipients[0]));
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
if (throwException)
{
Assert.AreEqual(0, _server.ReceivedEmailCount);
}
else
{
if (setMimeMessageToNull)
{
Assert.AreEqual(0, _server.ReceivedEmailCount);
}
else
{
Assert.AreEqual(1, _server.ReceivedEmailCount);
}
}
_server.ClearReceivedEmail();
#endregion
#region * Async send methods *
// send enumerable data
mmm.PlainText = plainText; // set text from constant
try
{
if (throwException)
{
Assert.ThrowsAsync <MailMergeMessage.MailMergeMessageException>(async() =>
await mms.SendAsync(mmm, recipients));
}
else
{
if (setMimeMessageToNull)
{
Assert.ThrowsAsync <MailMergeMessage.MailMergeMessageException>(async() =>
await mms.SendAsync(mmm, recipients));
}
else
{
Assert.DoesNotThrow(() => mms.Send(mmm, recipients));
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
if (throwException)
{
Assert.AreEqual(0, _server.ReceivedEmailCount);
}
else
{
if (setMimeMessageToNull)
{
Assert.AreEqual(0, _server.ReceivedEmailCount);
}
else
{
Assert.AreEqual(recipients.Count, _server.ReceivedEmailCount);
}
}
_server.ClearReceivedEmail();
// send single data item
mmm.PlainText = plainText; // set text from constant
try
{
if (throwException)
{
Assert.ThrowsAsync <MailMergeMessage.MailMergeMessageException>(async() =>
await mms.SendAsync(mmm, recipients[0]));
}
else
{
if (setMimeMessageToNull)
{
Assert.ThrowsAsync <MailMergeMessage.MailMergeMessageException>(async() =>
await mms.SendAsync(mmm, recipients[0]));
}
else
{
Assert.DoesNotThrow(() => mms.Send(mmm, recipients[0]));
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
if (throwException)
{
Assert.AreEqual(0, _server.ReceivedEmailCount);
}
else
{
if (setMimeMessageToNull)
{
Assert.AreEqual(0, _server.ReceivedEmailCount);
}
else
{
Assert.AreEqual(1, _server.ReceivedEmailCount);
}
}
#endregion
mms.Dispose();
mmm.Dispose();
}
public void Init()
{
_server.ClearReceivedEmail();
}
public void CanRunAndReturnsUserResultSuccess()
{
const string eventName = "RadonWFTestMessage CanRunAndReturnsUserResultSuccess";
WriteToLogWithStandardLog(eventName, EventLogEntryType.Error, 666);
var outParams = RunWorkflow(GetEmailSettings(), GetFilterSettings("EntryType = \"Error\" And EventID = 666"));
Assert.That(outParams.UserResultMessage, Iz.EqualTo("Mail sent to [email protected]"));
Assert.That(smtpServer.ReceivedEmailCount, Is.EqualTo(1));
var body = SmtpSenderTest.ParseMessageBody(smtpServer.ReceivedEmail.Single().Body);
Assert.That(body, Does.Contain(eventName));
smtpServer.ClearReceivedEmail();
}
public void Setup()
{
smtpServer = SimpleSmtpServer.Start();
smtpServer.ClearReceivedEmail();
}
public void Cleanup()
{
_Server.ClearReceivedEmail();
}
public void SetUp()
{
_Server = SimpleSmtpServer.Start(_Rnd.Next(50000, 60000));
_Server.ClearReceivedEmail();
}
