public void TestHeaderParser()
{
var bytes = Encoding.ASCII.GetBytes("Header-1: value 1\r\nHeader-2: value 2\r\nHeader-3: value 3\r\n\r\n");
using (var memory = new MemoryStream(bytes, false)) {
try {
var headers = HeaderList.Load(memory);
string value;
Assert.AreEqual(3, headers.Count, "Unexpected header count.");
value = headers["Header-1"];
Assert.AreEqual("value 1", value, "Unexpected header value.");
value = headers["Header-2"];
Assert.AreEqual("value 2", value, "Unexpected header value.");
value = headers["Header-3"];
Assert.AreEqual("value 3", value, "Unexpected header value.");
} catch (Exception ex) {
Assert.Fail("Failed to parse headers: {0}", ex);
}
}
}
public void TestEmptyHeaders()
{
var bytes = Encoding.ASCII.GetBytes("\r\n");
using (var memory = new MemoryStream(bytes, false)) {
try {
var headers = HeaderList.Load(memory);
Assert.AreEqual(0, headers.Count, "Unexpected header count.");
} catch (Exception ex) {
Assert.Fail("Failed to parse headers: {0}", ex);
}
}
}
public void TestTruncatedHeaderName()
{
var bytes = Encoding.ASCII.GetBytes("Header-1");
using (var memory = new MemoryStream(bytes, false)) {
try {
var headers = HeaderList.Load(memory);
Assert.Fail("Parsing headers should fail.");
} catch (FormatException) {
} catch (Exception ex) {
Assert.Fail("Failed to parse headers: {0}", ex);
}
}
}
public void TestSingleHeaderNoTerminator()
{
var bytes = Encoding.ASCII.GetBytes("Header-1: value 1\r\n");
using (var memory = new MemoryStream(bytes, false)) {
try {
var headers = HeaderList.Load(memory);
Assert.AreEqual(1, headers.Count, "Unexpected header count.");
var value = headers["Header-1"];
Assert.AreEqual("value 1", value, "Unexpected header value.");
} catch (Exception ex) {
Assert.Fail("Failed to parse headers: {0}", ex);
}
}
}
public static MessageModel GetMessageModelFromFile(string emailFile)
{
var messageHeaders = HeaderList.Load(emailFile);
MessageModel message = new MessageModel()
{
Message_ID = messageHeaders[HeaderId.MessageId],
Subject = messageHeaders[HeaderId.Subject],
From = messageHeaders[HeaderId.From],
To = messageHeaders[HeaderId.To],
Date = messageHeaders[HeaderId.Date]
};
if (message.From == null || message.Date == null)
{
throw new FormatException();
}
if (String.IsNullOrEmpty(message.Message_ID))
{
message.Message_ID = "<" + Guid.NewGuid().ToString() + message.From.Substring(message.From.IndexOf('@')) + ">";
}
return(message);
}
public void TestArgumentExceptions()
{
var list = new HeaderList();
Header header;
string value;
using (var stream = new MemoryStream()) {
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(null, "filename.txt"));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(ParserOptions.Default, (string)null));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(null, stream));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(ParserOptions.Default, (Stream)null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(null, "filename.txt"));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(ParserOptions.Default, (string)null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(null, stream));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(ParserOptions.Default, (Stream)null));
}
// Add
Assert.Throws <ArgumentNullException> (() => list.Add(null));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Add(HeaderId.Unknown, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add(HeaderId.AdHoc, null));
Assert.Throws <ArgumentNullException> (() => list.Add(null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add("field", null));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Add(HeaderId.Unknown, Encoding.UTF8, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add(HeaderId.AdHoc, null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add(HeaderId.AdHoc, Encoding.UTF8, null));
Assert.Throws <ArgumentNullException> (() => list.Add(null, Encoding.UTF8, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add("field", null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add("field", Encoding.UTF8, null));
// Contains
Assert.Throws <ArgumentOutOfRangeException> (() => list.Contains(HeaderId.Unknown));
Assert.Throws <ArgumentNullException> (() => list.Contains((Header)null));
Assert.Throws <ArgumentNullException> (() => list.Contains((string)null));
// CopyTo
Assert.Throws <ArgumentOutOfRangeException> (() => list.CopyTo(new Header[0], -1));
Assert.Throws <ArgumentNullException> (() => list.CopyTo(null, 0));
// IndexOf
Assert.Throws <ArgumentOutOfRangeException> (() => list.IndexOf(HeaderId.Unknown));
Assert.Throws <ArgumentNullException> (() => list.IndexOf((Header)null));
Assert.Throws <ArgumentNullException> (() => list.IndexOf((string)null));
// Insert
list.Add("field", "value");
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(-1, new Header(HeaderId.AdHoc, "value")));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(-1, HeaderId.AdHoc, Encoding.UTF8, "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(-1, "field", Encoding.UTF8, "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(-1, HeaderId.AdHoc, "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(-1, "field", "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(0, HeaderId.Unknown, Encoding.UTF8, "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(0, HeaderId.Unknown, "value"));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, HeaderId.AdHoc, Encoding.UTF8, null));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, HeaderId.AdHoc, null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, HeaderId.AdHoc, null));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, "field", null));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, null));
// LastIndexOf
Assert.Throws <ArgumentOutOfRangeException> (() => list.LastIndexOf(HeaderId.Unknown));
Assert.Throws <ArgumentNullException> (() => list.LastIndexOf((string)null));
// Remove
Assert.Throws <ArgumentOutOfRangeException> (() => list.Remove(HeaderId.Unknown));
Assert.Throws <ArgumentNullException> (() => list.Remove((Header)null));
Assert.Throws <ArgumentNullException> (() => list.Remove((string)null));
// RemoveAll
Assert.Throws <ArgumentOutOfRangeException> (() => list.RemoveAll(HeaderId.Unknown));
Assert.Throws <ArgumentNullException> (() => list.RemoveAll((string)null));
// RemoveAt
Assert.Throws <ArgumentOutOfRangeException> (() => list.RemoveAt(-1));
// Replace
Assert.Throws <ArgumentNullException> (() => list.Replace(null));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Replace(HeaderId.Unknown, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace(HeaderId.AdHoc, null));
Assert.Throws <ArgumentNullException> (() => list.Replace(null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace("field", null));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Replace(HeaderId.Unknown, Encoding.UTF8, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace(HeaderId.AdHoc, null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace(HeaderId.AdHoc, Encoding.UTF8, null));
Assert.Throws <ArgumentNullException> (() => list.Replace(null, Encoding.UTF8, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace("field", null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace("field", Encoding.UTF8, null));
using (var stream = new MemoryStream()) {
// Load
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(ParserOptions.Default, (Stream)null));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(ParserOptions.Default, (string)null));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(null, stream));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load((Stream)null));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load((string)null));
// LoadAsync
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(ParserOptions.Default, (Stream)null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(ParserOptions.Default, (string)null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(null, stream));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync((Stream)null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync((string)null));
// WriteTo
Assert.Throws <ArgumentNullException> (() => list.WriteTo(FormatOptions.Default, null));
Assert.Throws <ArgumentNullException> (() => list.WriteTo(null, stream));
Assert.Throws <ArgumentNullException> (() => list.WriteTo(null));
// WriteToAsync
Assert.ThrowsAsync <ArgumentNullException> (async() => await list.WriteToAsync(FormatOptions.Default, null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await list.WriteToAsync(null, stream));
Assert.ThrowsAsync <ArgumentNullException> (async() => await list.WriteToAsync(null));
}
// Indexers
Assert.Throws <ArgumentOutOfRangeException> (() => list[-1] = new Header(HeaderId.AdHoc, "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list[HeaderId.Unknown] = "value");
Assert.Throws <ArgumentOutOfRangeException> (() => value = list[HeaderId.Unknown]);
Assert.Throws <ArgumentOutOfRangeException> (() => header = list[-1]);
Assert.Throws <ArgumentNullException> (() => list[HeaderId.AdHoc] = null);
Assert.Throws <ArgumentNullException> (() => value = list[null]);
Assert.Throws <ArgumentNullException> (() => list[null] = "value");
Assert.Throws <ArgumentNullException> (() => list["field"] = null);
Assert.Throws <ArgumentNullException> (() => list[0] = null);
}
public MimeMessage ParseMessage()
{
//var result = new Email();
HeaderList headers;
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(_msg.Headers)))
{
headers = HeaderList.Load(stream);
}
var bodyParts = new List <MimeEntity>();
if (!string.IsNullOrEmpty(_msg.BodyText))
{
bodyParts.Add(new TextPart("plain")
{
Text = _msg.BodyText
});
}
if (!string.IsNullOrEmpty(_msg.BodyRtf))
{
bodyParts.Add(new TextPart("rtf")
{
Text = _msg.BodyRtf
});
}
if (!string.IsNullOrEmpty(_msg.BodyHtml))
{
bodyParts.Add(new TextPart("html")
{
Text = _msg.BodyHtml
});
}
MimeEntity root = null;
if (bodyParts.Count <= 0)
{
throw new InvalidOperationException("No message body found.");
}
if (bodyParts.Count == 1)
{
root = bodyParts[0];
}
else
{
var alt = new Multipart("alternative");
foreach (var body in bodyParts)
{
alt.Add(body);
}
root = alt;
}
if (_msg.Attachments.Any() || _msg.Messages.Any())
{
var mixed = new Multipart("mixed");
mixed.Add(root);
foreach (var attach in _msg.Attachments)
{
var mimeType = (string.IsNullOrEmpty(attach.MimeTag) ? "application/octet-stream" : attach.MimeTag).Split('/');
var mimeAttach = new MimePart(mimeType[0], mimeType[1])
{
ContentObject = new ContentObject(new MemoryStream(attach.Data)),
ContentDisposition = new ContentDisposition(ContentDisposition.Attachment),
ContentTransferEncoding = ContentEncoding.Base64,
ContentId = attach.ContentId,
FileName = attach.FileName,
};
mixed.Add(mimeAttach);
}
foreach (var message in _msg.Messages)
{
var stream = new MemoryStream();
message.WriteTo(stream);
stream.Position = 0;
var mimeAttach = new MimePart("application", "vnd.ms-outlook")
{
ContentObject = new ContentObject(stream),
ContentDisposition = new ContentDisposition(ContentDisposition.Attachment),
ContentTransferEncoding = ContentEncoding.Base64,
ContentId = message.MessageId,
FileName = (message.Subject ?? "") + ".msg"
};
mixed.Add(mimeAttach);
}
root = mixed;
}
return(new MimeMessage(headers, root));
}