public MailMergeMessage CreateStandardMessage()
{
var mmm = new MailMergeMessage
{
Config = Settings.MessageConfig,
PlainText = string.Empty,
HtmlText = string.Empty,
Subject = string.Empty,
};
mmm.MailMergeAddresses.Clear();
if (_siteContext?.Email?.GeneralFrom?.Address != null)
{
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From,
_siteContext.Email.GeneralFrom.DisplayName,
_siteContext.Email.GeneralFrom.Address));
}
if (_siteContext?.Email?.GeneralBcc != null)
{
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.Bcc,
_siteContext.Email.GeneralBcc.DisplayName,
_siteContext.Email.GeneralBcc.Address));
}
return(mmm);
}
public void FileBaseDirectory_must_be_full_path_when_processing_the_message(string path, bool shouldThrow)
{
var mmm = new MailMergeMessage("subject", "plain text", "<html><body></body></html>");
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "*****@*****.**"));
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, "*****@*****.**"));
mmm.Config.FileBaseDirectory = path;
if (shouldThrow)
{
try
{
mmm.GetMimeMessage(null);
}
catch (Exception e)
{
Assert.IsTrue(e is MailMergeMessage.MailMergeMessageException);
Assert.IsTrue(e.InnerException != null);
}
}
else
{
Assert.DoesNotThrow(() => mmm.GetMimeMessage(null));
}
}
//[TestCase(1000, Ignore = "Only for performance tests")]
public async Task SendSyncAndAsyncPerformance(int numOfRecipients)
{
// 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 < numOfRecipients; 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);
mms.Dispose();
mmm.Dispose();
}
private void SendMail(EventHandler <MailSenderAfterSendEventArgs> onAfterSend = null, EventHandler <MailSenderSmtpClientEventArgs> onSmtpConnected = null, EventHandler <MailSenderSmtpClientEventArgs> onSmtpDisconnected = null)
{
var data = new Dictionary <string, object>
{
{ "MessageText", "This is just a sample plain text." },
{ "Date", DateTime.Now }
};
var mmm = new MailMergeMessage("Mailsubject sent on {Date}", "{MessageText}")
{
Config = _settings.MessageConfig
};
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "Test name", "*****@*****.**"));
var mms = new MailMergeSender()
{
Config = _settings.SenderConfig
};
mms.OnAfterSend += onAfterSend;
mms.OnSmtpConnected += onSmtpConnected;
mms.OnSmtpDisconnected += onSmtpDisconnected;
mms.Send(mmm, (object)data);
}
public void MessagesFromDataRows()
{
var tbl = new DataTable();
tbl.Columns.Add("Email", typeof(string));
tbl.Columns.Add("Continent", typeof(string));
tbl.Rows.Add("*****@*****.**", "Europe");
tbl.Rows.Add("*****@*****.**", "Asia");
tbl.Rows.Add("*****@*****.**", "America");
var text = "Lorem ipsum dolor. Email={Email}, Continent={Continent}.";
var mmm = new MailMergeMessage("Subject for {Continent}", text);
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, "*****@*****.**"));
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "{Email}"));
var i = 0;
foreach (var mimeMessage in mmm.GetMimeMessages <DataRow>(tbl.Rows.OfType <DataRow>()))
{
Assert.IsTrue(mimeMessage.To.ToString().Contains(tbl.Rows[i]["Email"].ToString()));
Assert.IsTrue(mimeMessage.TextBody.Contains(text.Replace("{Email}", tbl.Rows[i]["Email"].ToString()).Replace("{Continent}", tbl.Rows[i]["Continent"].ToString())));
MailMergeMessage.DisposeFileStreams(mimeMessage);
i++;
}
}
public void DisposeFileStreamsOfMessageAttachments()
{
var dataItem = new
{
Name = "John",
MailboxAddr = "*****@*****.**",
Success = true,
Date = DateTime.Now,
SenderAddr = "*****@*****.**",
Image = MessageFactory.ImgSuccess
};
using (var mmm = MessageFactory.GetHtmlMailWithInlineAndOtherAttachments())
{
var mimeMsg = mmm.GetMimeMessage(dataItem);
foreach (var filename in new[] { MessageFactory.LogFileName, dataItem.Image })
{
// file streams are still in use
Assert.Throws <IOException>(() => File.OpenWrite(Path.Combine(TestFileFolders.FilesAbsPath, filename)));
}
// dispose file streams
MailMergeMessage.DisposeFileStreams(mimeMsg);
}
// now all files are fully accessible
foreach (var filename in new[] { MessageFactory.LogFileName, dataItem.Image })
{
var fs = File.OpenWrite(Path.Combine(TestFileFolders.FilesAbsPath, filename));
fs.Dispose();
}
}
public void HtmlMailMergeWithStreamAttachment()
{
var dataItem = new
{
Name = "John",
MailboxAddr = "*****@*****.**",
Success = true,
Date = DateTime.Now,
SenderAddr = "*****@*****.**"
};
var text = "Some test for stream attachment";
var streamAttFilename = $"StreamFilename_{dataItem.Date:yyyy-MM-dd}.txt";
using var mmm = MessageFactory.GetHtmlMailWithInlineAndOtherAttachments();
mmm.FileAttachments.Clear();
mmm.InlineAttachments.Clear();
mmm.StreamAttachments.Clear();
mmm.StringAttachments.Clear();
using var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(text ?? string.Empty));
mmm.StreamAttachments.Add(new StreamAttachment(stream, streamAttFilename, "text/plain"));
var msg = mmm.GetMimeMessage(dataItem);
var att = msg.Attachments.FirstOrDefault() as MimePart;
Assert.IsTrue(att?.FileName == streamAttFilename && att.IsAttachment);
Assert.IsTrue(msg.ToString().Contains(text));
MailMergeMessage.DisposeFileStreams(msg);
}
public void DeserializeMinimalisticXml()
{
// an empty deserialized message and new message must be equal
var mmm = MailMergeMessage.Deserialize("<MailMergeMessage></MailMergeMessage>");
Assert.True(new MailMergeMessage().Equals(mmm));
}
public void AddLinkedResourceManually()
{
const string myContentId = "my.content.id";
var filesAbsPath = Path.Combine(Helper.GetCodeBaseDirectory(), _pathRelativeToCodebase);
var dataItem = new
{
Name = "John",
MailboxAddr = "*****@*****.**",
Success = true,
Date = DateTime.Now,
SenderAddr = "*****@*****.**"
};
var mmm = new MailMergeMessage
{
HtmlText = $"<html><body><img src=\"cid:{myContentId}\" width=\"100\"><br/>only an image</body></html>",
PlainText = "only an image",
Subject = "Message subject",
Config = { FileBaseDirectory = filesAbsPath }
};
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, "{SenderAddr}"));
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "\"{Name}\" <{MailboxAddr}>", mmm.Config.CharacterEncoding));
mmm.AddExternalInlineAttachment(new FileAttachment(Path.Combine(filesAbsPath, "success.jpg"), myContentId));
var msg = mmm.GetMimeMessage(dataItem);
Assert.IsTrue(msg.BodyParts.Any(bp => bp.ContentDisposition?.Disposition == ContentDisposition.Inline && bp.ContentType.IsMimeType("image", "jpeg") && bp.ContentId == myContentId));
}
public void TryToSendWhenSenderIsBusy()
{
var mmm = new MailMergeMessage("Subject", "plain text");
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "Test name", "*****@*****.**"));
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "Test name 2", "*****@*****.**"));
var mms = new MailMergeSender
{
IsBusy = true
};
// single mail
Assert.Throws <InvalidOperationException>(() => mms.Send(mmm, new object()));
Assert.ThrowsAsync <InvalidOperationException>(async() => await mms.SendAsync(mmm, new object()));
// several mails
Assert.Throws <InvalidOperationException>(() => mms.Send(mmm, new Dictionary <string, string>()));
Assert.ThrowsAsync <InvalidOperationException>(async() =>
await mms.SendAsync(mmm, new Dictionary <string, string>()));
mms.IsBusy = false;
mmm.Dispose();
mms.Dispose();
}
public void HtmlMailMergeWithInlineAndAtt()
{
var dataItem = new
{
Name = "John",
MailboxAddr = "*****@*****.**",
Success = true,
Date = DateTime.Now,
SenderAddr = "*****@*****.**"
};
using var mmm = MessageFactory.GetHtmlMailWithInlineAndOtherAttachments();
var msg = mmm.GetMimeMessage(dataItem);
var msgFilename = Path.GetFullPath(Path.Combine(Path.GetTempPath(), "test-msg.eml"));
msg.WriteTo(msgFilename);
Console.WriteLine($"Test mime message saved as {msgFilename}");
Assert.IsTrue(((MailboxAddress)msg.From.First()).Address == dataItem.SenderAddr);
Assert.IsTrue(((MailboxAddress)msg.To.First()).Address == dataItem.MailboxAddr);
Assert.IsTrue(((MailboxAddress)msg.To.First()).Name == dataItem.Name);
Assert.IsTrue(msg.Headers[HeaderId.Organization] == mmm.Config.Organization);
Assert.IsTrue(msg.Priority == mmm.Config.Priority);
Assert.IsTrue(msg.Attachments.FirstOrDefault(a => ((MimePart)a).FileName == "Log file from {Date:yyyy-MM-dd}.log".Replace("{Date:yyyy-MM-dd}", dataItem.Date.ToString("yyyy-MM-dd"))) != null);
Assert.IsTrue(msg.Subject == mmm.Subject.Replace("{Date:yyyy-MM-dd}", dataItem.Date.ToString("yyyy-MM-dd")));
Assert.IsTrue(msg.HtmlBody.Contains(dataItem.Success ? "succeeded" : "failed"));
Assert.IsTrue(msg.TextBody.Contains(dataItem.Success ? "succeeded" : "failed"));
Assert.IsTrue(msg.BodyParts.Any(bp => bp.ContentDisposition?.Disposition == ContentDisposition.Inline && bp.ContentType.IsMimeType("image", "jpeg")));
MailMergeMessage.DisposeFileStreams(msg);
}
public void CancelSendOperationWithDelay()
{
var mmm = new MailMergeMessage("Cancel with delay", "plain text");
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "Test name", "*****@*****.**"));
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, "Test name 2", "*****@*****.**"));
var mms = new MailMergeSender
{
Config = _settings.SenderConfig
};
mms.Config.MaxNumOfSmtpClients = 1;
mms.Config.SmtpClientConfig[0].MessageOutput = MessageOutput.SmtpServer;
mms.Config.SmtpClientConfig[0].DelayBetweenMessages = 2000;
var anyData = new[] { new { mailNo = 1 }, new { mailNo = 2 }, new { mailNo = 3 } };
mms.SendCancel(500);
Assert.ThrowsAsync <TaskCanceledException>(() => mms.SendAsync(mmm, anyData));
Assert.AreEqual(0, _server.ReceivedEmailCount);
mmm.Dispose();
mms.Dispose();
}
public async Task CancelSendOperation()
{
var mmm = new MailMergeMessage("Cancel immediately", "plain text");
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "Test name", "*****@*****.**"));
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, "Test name 2", "*****@*****.**"));
var mms = new MailMergeSender {
Config = _settings.SenderConfig
};
mms.Config.MaxNumOfSmtpClients = 1;
mms.Config.SmtpClientConfig[0].MessageOutput = MessageOutput.SmtpServer;
mms.Config.SmtpClientConfig[0].DelayBetweenMessages = 2000;
var anyData = new[] { new { mailNo = 1 }, new { mailNo = 2 }, new { mailNo = 3 } };
var tasks = new[]
{
await Task.Factory.StartNew(async() => await mms.SendAsync(mmm, anyData)),
Task.Factory.StartNew(() => mms.SendCancel()),
Task.Factory.StartNew(() => mms.SendCancel()) // a second cancel operation will just return
};
Assert.Throws <AggregateException>(() => { Task.WaitAll(tasks); });
Assert.AreEqual(0, _server.ReceivedEmailCount);
mms.Dispose();
mmm.Dispose();
}
public void MessagesFromJsonArray()
{
var recipients = JArray.Parse(@"
[
{
'Email': '*****@*****.**',
'Name': 'John'
},
{
'Email': '*****@*****.**',
'Name': 'Mary'
},
{
'Email': '*****@*****.**',
'Name': 'Steve'
}
]
");
var mmm = new MailMergeMessage("Get MimeMessages JSON Test", string.Empty, "<html><head></head><body>This is the plain text part for {Name} ({Email})</body></html>");
mmm.ConvertHtmlToPlainText();
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, "*****@*****.**"));
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "{Name}", "{Email}"));
var cnt = 0;
foreach (var mimeMessage in mmm.GetMimeMessages(recipients))
{
Assert.IsTrue(mimeMessage.TextBody == string.Format($"This is the plain text part for {recipients[cnt]["Name"]} ({recipients[cnt]["Email"]})"));
Assert.IsTrue(mimeMessage.HtmlBody.Contains(string.Format($"This is the plain text part for {recipients[cnt]["Name"]} ({recipients[cnt]["Email"]})")));
Assert.IsTrue(mimeMessage.To.ToString().Contains(recipients[cnt]["Name"].ToString()) && mimeMessage.To.ToString().Contains(recipients[cnt]["Email"].ToString()));
MailMergeMessage.DisposeFileStreams(mimeMessage);
cnt++;
}
}
public void HtmlMailMergeWithMoreEqualInlineAtt()
{
var dataItem = new
{
Name = "John",
MailboxAddr = "*****@*****.**",
Success = true,
Date = DateTime.Now,
SenderAddr = "*****@*****.**",
Image = MessageFactory.ImgSuccess
};
var mmm = MessageFactory.GetHtmlMsgWithThreeInlineAttachments();
var msg = mmm.GetMimeMessage(dataItem);
var msgFilename = Path.GetFullPath(Path.Combine(Path.GetTempPath(), "test-msg-equal-inline-att.eml"));
msg.WriteTo(msgFilename);
Console.WriteLine($"Test mime message saved as {msgFilename}");
Assert.IsTrue(new HtmlParser().Parse(msg.HtmlBody).All.Count(m => m is IHtmlImageElement) == 3);
Assert.IsTrue(msg.BodyParts.Count(bp => bp.ContentDisposition?.Disposition == ContentDisposition.Inline && bp.ContentType.IsMimeType("image", "jpeg")) == 1);
MailMergeMessage.DisposeFileStreams(msg);
}
public void MessagesFromList()
{
var recipients = new List <Recipient>();
for (var i = 0; i < 10; i++)
{
recipients.Add(new Recipient()
{
Email = $"recipient-{i}@example.com", Name = $"Name of {i}"
});
}
var mmm = new MailMergeMessage("Get MimeMessages Test", string.Empty, "<html><head></head><body>This is the plain text part for {Name} ({Email})</body></html>");
mmm.ConvertHtmlToPlainText();
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, "*****@*****.**"));
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "{Name}", "{Email}"));
var cnt = 0;
foreach (var mimeMessage in mmm.GetMimeMessages <Recipient>(recipients))
{
Assert.IsTrue(mimeMessage.TextBody == string.Format($"This is the plain text part for {recipients[cnt].Name} ({recipients[cnt].Email})"));
Assert.IsTrue(mimeMessage.HtmlBody.Contains(string.Format($"This is the plain text part for {recipients[cnt].Name} ({recipients[cnt].Email})")));
Assert.IsTrue(mimeMessage.To.ToString().Contains(recipients[cnt].Name) && mimeMessage.To.ToString().Contains(recipients[cnt].Email));
MailMergeMessage.DisposeFileStreams(mimeMessage);
cnt++;
// The message could be sent using the low-level API using a configured SmtpClient:
// new SmtpClient().Send(FormatOptions.Default, mimeMessage);
}
}
public void SetHtmlBuilderDocBaseUri_NoException(string baseUri)
{
var mmm = new MailMergeMessage("subject", "plain text", "<html><head><base href=\"\" /></head><body></body></html>");
var hbb = new HtmlBodyBuilder(mmm, (object)null);
Assert.DoesNotThrow(() => hbb.DocBaseUri = baseUri);
}
public void MissingVariableAndAttachmentsExceptions()
{
// build message with a total of 8 placeholders which will be missing
var mmm = new MailMergeMessage("Missing in subject {subject}", "Missing in plain text {plain}",
"<html><head></head><body>{html}</body></html>");
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, "{from.address}"));
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "{to.address}"));
mmm.AddExternalInlineAttachment(new FileAttachment("{inlineAtt.filename}.jpg", string.Empty));
mmm.FileAttachments.Add(new FileAttachment("{fileAtt.filename}.xml", "{fileAtt.displayname}"));
try
{
var mimeMessage = mmm.GetMimeMessage(default(object));
Assert.Fail("Expected exceptions not thrown.");
}
catch (MailMergeMessage.MailMergeMessageException exceptions)
{
Console.WriteLine($"Aggregate {nameof(MailMergeMessage.MailMergeMessageException)} thrown. Passed.");
Console.WriteLine();
/* Expected exceptions:
* 1) 8 missing variables for {placeholders}
* 2) No recipients
* 3) No FROM address
* 4) Missing file attachment {fileAtt.filename}.xml
* 5) Missing inline attachment {inlineAtt.filename}.jpg
*/
Assert.That(exceptions.InnerExceptions.Count == 5);
foreach (var ex in exceptions.InnerExceptions.Where(ex => !(ex is MailMergeMessage.AttachmentException)))
{
if (ex is MailMergeMessage.VariableException)
{
Assert.AreEqual(8, (ex as MailMergeMessage.VariableException).MissingVariable.Count);
Console.WriteLine($"{nameof(MailMergeMessage.VariableException)} thrown successfully:");
Console.WriteLine("Missing variables: " +
string.Join(", ", (ex as MailMergeMessage.VariableException).MissingVariable));
}
if (ex is MailMergeMessage.AddressException)
{
Console.WriteLine($"{nameof(MailMergeMessage.AddressException)} thrown successfully:");
Console.WriteLine((ex as MailMergeMessage.AddressException).Message);
Assert.That((ex as MailMergeMessage.AddressException).Message == "No recipients." ||
(ex as MailMergeMessage.AddressException).Message == "No from address.");
}
}
// one exception for a missing file attachment, one for a missing inline attachment
var attExceptions = exceptions.InnerExceptions.Where(ex => ex is MailMergeMessage.AttachmentException).ToList();
Assert.AreEqual(2, attExceptions.Count);
foreach (var ex in attExceptions)
{
Console.WriteLine($"{nameof(MailMergeMessage.AttachmentException)} thrown successfully:");
Console.WriteLine("Missing files: " + string.Join(", ", (ex as MailMergeMessage.AttachmentException).BadAttachment));
Assert.AreEqual(1, (ex as MailMergeMessage.AttachmentException).BadAttachment.Count);
}
}
}
private MimeMessage GetMimeMessage()
{
var mmm = new MailMergeMessage("subject", "plain text");
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "*****@*****.**"));
mmm.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, "*****@*****.**"));
return(mmm.GetMimeMessage());
}
public void TryToSendWithNullAsEnumerable()
{
var mms = new MailMergeSender();
var mmm = new MailMergeMessage(); // no need to fully prepare for this test
Assert.Throws <ArgumentNullException>(() => mms.Send(null, (Dictionary <string, string>)null));
Assert.ThrowsAsync <ArgumentNullException>(async() => await mms.SendAsync(mmm, (Dictionary <string, string>)null));
}
public void CreateTextMessageWithFileAttachments()
{
using var basicMmm = MessageFactory.GetHtmlMailWithInlineAndOtherAttachments();
using var mmm = new MailMergeMessage("The subject", "plain text", basicMmm.FileAttachments);
Assert.AreEqual("The subject", mmm.Subject);
Assert.AreEqual("plain text", mmm.PlainText);
Assert.AreEqual(basicMmm.FileAttachments.Count, mmm.FileAttachments.Count);
}
public void SerializationFromToString()
{
var mmm = MessageFactory.GetMessageWithAllPropertiesSet();
var result = mmm.Serialize();
var back = MailMergeMessage.Deserialize(result);
Assert.True(mmm.Equals(back));
Assert.AreEqual(mmm.Serialize(), back.Serialize());
}
public void MailMergeAddressCollectionToString()
{
var mmm = new MailMergeMessage();
mmm.MailMergeAddresses.Add(_addr1a);
mmm.MailMergeAddresses.Add(_addr2a);
Assert.AreEqual($"\"{_addr1a.DisplayName}\" <{_addr1a.Address}>", mmm.MailMergeAddresses.ToString(MailAddressType.To, null));
}
public void NonExistingTitleTagSetWithSubject()
{
var subjectToSet = "subject_to_set";
var mmm = new MailMergeMessage(subjectToSet, "plain text", "<html><head></head><body></body></html>");
var hbb = new HtmlBodyBuilder(mmm, (object)null);
var html = hbb.GetBodyPart();
Assert.IsTrue(!html.ToString().Contains(subjectToSet));
}
public void ScriptTagRemoved()
{
var mmm = new MailMergeMessage("subject_to_set", "plain text", "<html><head><script>var x='x';</script><script>var y='y';</script></head><body>some body</body></html>");
var hbb = new HtmlBodyBuilder(mmm, (object)null);
var html = hbb.GetBodyPart();
Assert.IsTrue(html.ToString().Contains("some body"));
Assert.IsTrue(!html.ToString().Contains("script"));
}
public void MessageConfig_FileBaseDirectory_cannot_be_changed_by_Html_Base_Tag()
{
var mmm = new MailMergeMessage("subject", "plain text",
"<html><head><base href=\"\" /></head><body></body></html>");
mmm.Config.FileBaseDirectory = Path.GetTempPath();
var hbb = new HtmlBodyBuilder(mmm, (object)null);
Assert.AreEqual(new Uri(mmm.Config.FileBaseDirectory), hbb.DocBaseUri);
}
public void SerializationFromToFile()
{
var filename = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
var mmm = MessageFactory.GetMessageWithAllPropertiesSet();
mmm.Serialize(filename, Encoding.Unicode);
var back = MailMergeMessage.Deserialize(filename, Encoding.Unicode);
Assert.True(mmm.Equals(back));
Assert.AreEqual(mmm.Serialize(), back.Serialize());
}
public MailMergeMessage CreateStandardMessage()
{
var mmm = new MailMergeMessage
{
Config = Settings.MessageConfig,
PlainText = string.Empty,
HtmlText = string.Empty,
Subject = string.Empty,
};
return(mmm);
}
public static MailMergeMessage ConfigMessage()
{
//here we build up our subject and message in the constructor of the email...
var mailMessage = new MailMergeMessage("An email for {Name}",
"A simple message for {Name}");
//here we build up our from and to addresses, we use our values from our dictionary for the to...
mailMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.From, "*****@*****.**"));
mailMessage.MailMergeAddresses.Add(new MailMergeAddress(MailAddressType.To, "{Name}", "{Email}"));
return(mailMessage);
}
public void Empty_MessageConfig_FileBaseDirectory_is_changed_by_Html_Base_Tag()
{
var baseTagHref = "file:///C:/Temp/";
var mmm = new MailMergeMessage("subject", "plain text",
$"<html><head><base href=\"{baseTagHref}\" /></head><body></body></html>");
mmm.Config.FileBaseDirectory = string.Empty;
var hbb = new HtmlBodyBuilder(mmm, (object)null);
hbb.GetBodyPart();
Assert.AreEqual(baseTagHref, hbb.DocBaseUri);
}
