public void TestDataHandler()
{
var expectedSender = new MailPath("tester", "test.de");
var expectedRecipients = new List <MailPath> {
new MailPath("tester", "fubar.de")
};
var expectedBody = "Body";
AddTransactionProperty("ReversePath", () => expectedSender);
AddTransactionListProperty("ForwardPath", () => expectedRecipients);
var reset = false;
Transaction.Reset = () => { reset = true; };
MailPath actualSender = null;
List <MailPath> actualRecipients = null;
string actualBody = null;
Core.TriggerNewMessageSMTPTransactionMailPathMailPathArrayString =
(transaction, sender, recipients, body) =>
{
actualSender = sender;
actualRecipients = recipients.ToList();
actualBody = body;
};
var response = DATAHandler.DataHandler(Transaction, expectedBody);
Assert.Equal(SMTPStatusCode.Okay, response.Code);
Assert.Equal(expectedSender, actualSender);
Assert.Equal(expectedRecipients, actualRecipients);
Assert.Equal(expectedBody, actualBody);
Assert.True(reset);
}
public void TestTriggerNewMessage()
{
var core = new SMTPServer(DefaultLoader());
var settings = new StubIReceiveSettings();
var expectedTransaction = new StubSMTPTransaction(core, settings);
var expectedSender = new MailPath("tester", "test.de");
var expectedRecipients = new[] { new MailPath("fubar", "fu.com") };
var expectedBody = "Test";
SMTPTransaction actualTransaction = null;
Mail actualMail = null;
var triggered = false;
core.OnNewMessage += (transaction, mail) =>
{
triggered = true;
actualTransaction = transaction;
actualMail = mail;
};
core.TriggerNewMessage(expectedTransaction, expectedSender, expectedRecipients, expectedBody);
// TODO: Remove dependencies of test
Assert.True(triggered);
Assert.Equal(expectedTransaction, actualTransaction);
Assert.Equal(expectedSender.ToMailAdress(), actualMail.From);
Assert.Equal(expectedRecipients.Select(r => r.ToMailAdress().ToString()).ToArray(),
actualMail.Recipients.Select(r => r.ToString()).ToArray());
Assert.Equal(expectedBody, actualMail.Body);
}
public void TestToToMailAdress()
{
var path = new MailPath("tester", "test.de");
Assert.Equal(new MailAddress("*****@*****.**"), path.ToMailAdress());
Assert.Null(MailPath.Empty.ToMailAdress());
Assert.Null(MailPath.Postmaster.ToMailAdress());
}
public void TestFromString(string input, string localPart, string domain, string[] atDomains)
{
var path = MailPath.FromString(input);
Assert.Equal(localPart, path.LocalPart);
Assert.Equal(domain, path.Domain);
Assert.Equal(atDomains, path.AtDomains);
}
public void TriggerNewMessage(SMTPTransaction transaction, MailPath sender, MailPath[] recipients, string body)
{
var mail = new Mail(sender.ToMailAdress(), recipients.Select(r => r.ToMailAdress()).Where(r => r != null),
body);
if (OnNewMessage != null)
{
OnNewMessage(transaction, mail);
}
}
public void TestEquals()
{
var path1 = new MailPath("tester", "test.de");
var path2 = new MailPath("Tester", "Test.de");
var path3 = new MailPath("tester2", "test.de");
var path4 = new MailPath("tester", "test.de", "fubar.de");
Assert.Equal(path1, path2);
Assert.NotEqual(path1, path3);
Assert.Equal(path1, path4);
Assert.NotEqual(path2, path3);
Assert.Equal(path2, path4);
Assert.NotEqual(path3, path4);
Assert.False(path1.Equals(null));
Assert.False(path1.Equals((object)null));
Assert.False(path1.Equals(new object()));
Assert.True(path1.Equals((object)path1));
Assert.True(path1.Equals((object)path2));
Assert.False(path1.Equals((object)path3));
}
public override SMTPResponse DoExecute(SMTPTransaction transaction, string parameters)
{
if (transaction.GetProperty <bool>("MailInProgress"))
{
return(new SMTPResponse(SMTPStatusCode.BadSequence));
}
var match = FromRegex.Match(parameters);
if (!match.Success)
{
return(new SMTPResponse(SMTPStatusCode.SyntaxError));
}
var path = match.Groups[1].Value.Equals("<>") ? MailPath.Empty : MailPath.FromMatch(match);
transaction.SetProperty("ReversePath", path);
transaction.SetProperty("MailInProgress", true);
return(new SMTPResponse(SMTPStatusCode.Okay));
}
public override SMTPResponse DoExecute(SMTPTransaction transaction, string parameters)
{
if (!transaction.GetProperty <bool>("MailInProgress"))
{
return(new SMTPResponse(SMTPStatusCode.BadSequence));
}
var match = ToRegex.Match(parameters);
if (!match.Success)
{
return(new SMTPResponse(SMTPStatusCode.SyntaxError));
}
var path = match.Groups[1].Value.Equals("<postmaster>", StringComparison.InvariantCultureIgnoreCase)
? MailPath.Postmaster
: MailPath.FromMatch(match);
transaction.GetListProperty <MailPath>("ForwardPath").Add(path);
return(new SMTPResponse(SMTPStatusCode.Okay));
}
public void TestSuccess(string email, string localPart, string domain)
{
AddTransactionProperty("MailInProgress", false);
var inProgress = false;
MailPath reversePath = null;
Transaction.SetPropertyStringObjectBoolean = (name, value, _) =>
{
switch (name)
{
case "MailInProgress":
inProgress = (bool)value;
break;
case "ReversePath":
reversePath = (MailPath)value;
break;
default:
throw new InvalidOperationException("The name is invalid...");
}
};
var handler = new MAILHandler();
handler.Initialize(Core);
var response = handler.Execute(Transaction, string.Format("FROM:<{0}>", email));
Assert.Equal(SMTPStatusCode.Okay, response.Code);
Assert.NotNull(reversePath);
Assert.Equal(localPart, reversePath.LocalPart);
Assert.Equal(domain, reversePath.Domain);
Assert.True(inProgress);
}
public void TestToString(string output, string localPart, string domain, string[] atDomains)
{
var path = new MailPath(localPart, domain, atDomains);
Assert.Equal(output, path.ToString());
}
public void TestFromStringError(string input)
{
Assert.Throws <ArgumentException>(() => MailPath.FromString(input));
}
