public void TestDistributionListModeAnnouncer()
{
var recipients = new List<string>();
recipients.Add("*****@*****.**");
recipients.Add("*****@*****.**");
recipients.Add("*****@*****.**");
var list = SingletonProvider<TestSetup>.Instance.AddDistributionList(_domain, "*****@*****.**", recipients);
SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
var announcer = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
// Switch list mode so that only a single announcer can send to list.
list.Mode = eDistributionListMode.eLMAnnouncement;
list.RequireSenderAddress = announcer.Address;
list.RequireSMTPAuth = false;
list.Save();
var smtpClient = new SmtpClientSimulator();
CustomAsserts.Throws<DeliveryFailedException>(() => smtpClient.Send("*****@*****.**", list.Address, "Mail 1", "Mail 1"));
smtpClient.Send(announcer.Address, list.Address, "Mail 1", "Mail 1");
foreach (var recipient in recipients)
ImapClientSimulator.AssertMessageCount(recipient, "test", "Inbox", 1);
}
public void TestDomainAliases()
{
// Create a test account
// Fetch the default domain
DomainAlias oDomainAlias = _domain.DomainAliases.Add();
oDomainAlias.AliasName = "alias.com";
oDomainAlias.Save();
Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**",
"test");
// Send 5 messages to this account.
var smtpClientSimulator = new SmtpClientSimulator();
for (int i = 0; i < 5; i++)
smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "INBOX", "Alias test message");
Pop3ClientSimulator.AssertMessageCount("*****@*****.**", "test", 5);
{
oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain,
"*****@*****.**", "test");
// Set up an alias pointing at the domain alias.
SingletonProvider<TestSetup>.Instance.AddAlias(_domain, "*****@*****.**",
"*****@*****.**");
// Send to the alias
for (int i = 0; i < 5; i++)
smtpClientSimulator.Send(oAccount.Address, "*****@*****.**", "INBOX", "Plus addressing message");
// Wait for completion
Pop3ClientSimulator.AssertMessageCount(oAccount.Address, "test", 5);
}
}
public void TestDistributionListAnnouncementFromDomainAlias()
{
var smtpClientSimulator = new SmtpClientSimulator();
//
// TEST LIST SECURITY IN COMBINATION WITH DOMAIN NAME ALIASES
//
Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
var oRecipients = new List<string>();
oRecipients.Add("*****@*****.**");
DistributionList oList3 = SingletonProvider<TestSetup>.Instance.AddDistributionList(_domain, "*****@*****.**",
oRecipients);
oList3.Mode = eDistributionListMode.eLMAnnouncement;
oList3.RequireSenderAddress = "*****@*****.**";
oList3.Save();
// THIS MESSAGE SHOULD FAIL
CustomAsserts.Throws<DeliveryFailedException>(()=> smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "Mail 1", "Mail 1"));
DomainAlias oDA = _domain.DomainAliases.Add();
oDA.AliasName = "dummy-example.com";
oDA.Save();
// THIS MESSAGE SHOULD SUCCEED
smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "Mail 1", "Mail 1");
ImapClientSimulator.AssertMessageCount("*****@*****.**", "test", "Inbox", 1);
}
public void RequestingSameHeaderFieldMultipleTimesShouldReturnItOnce()
{
Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
string message = "From: Someone <*****@*****.**>" + Environment.NewLine +
"To: Someoen <*****@*****.**>" + Environment.NewLine +
"Date: Wed, 22 Apr 2009 11:05:09 \"GMT\"" + Environment.NewLine +
"Subject: SubjectText" + Environment.NewLine +
Environment.NewLine +
"Hello" + Environment.NewLine;
var smtpSimulator = new SmtpClientSimulator();
smtpSimulator.SendRaw(account.Address, account.Address, message);
Pop3ClientSimulator.AssertMessageCount(account.Address, "test", 1);
var oSimulator = new ImapClientSimulator();
string sWelcomeMessage = oSimulator.Connect();
oSimulator.Logon(account.Address, "test");
oSimulator.SelectFolder("INBOX");
string result = oSimulator.Fetch("1 BODY.PEEK[HEADER.FIELDS (Subject Subject)]");
oSimulator.Disconnect();
Assert.AreEqual(1, StringExtensions.Occurences(result, "SubjectText"));
}
public void IfInReplyToFieldContainsQuoteThenFetchHeadersShouldEncodeIt()
{
Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
string message = "From: Someone <*****@*****.**>" + Environment.NewLine +
"To: Someoen <*****@*****.**>" + Environment.NewLine +
"In-Reply-To: ShouldBeEncodedDueToQuote\"" + Environment.NewLine +
"Subject: Something" + Environment.NewLine +
Environment.NewLine +
"Hello" + Environment.NewLine;
var smtpSimulator = new SmtpClientSimulator();
smtpSimulator.SendRaw(account.Address, account.Address, message);
Pop3ClientSimulator.AssertMessageCount(account.Address, "test", 1);
var oSimulator = new ImapClientSimulator();
string sWelcomeMessage = oSimulator.Connect();
oSimulator.Logon(account.Address, "test");
oSimulator.SelectFolder("INBOX");
string result = oSimulator.Fetch("1 ENVELOPE");
oSimulator.Disconnect();
Assert.IsFalse(result.Contains("ShouldBeEncodedDueToQuote"));
}
public void TestBlockingDeliveries()
{
SecurityRange range =
SingletonProvider<TestSetup>.Instance.GetApp().Settings.SecurityRanges.get_ItemByName("My computer");
range.RequireSMTPAuthLocalToLocal = false;
range.RequireSMTPAuthLocalToExternal = false;
range.RequireSMTPAuthExternalToLocal = false;
range.RequireSMTPAuthExternalToExternal = false;
range.AllowDeliveryFromLocalToLocal = false;
range.AllowDeliveryFromLocalToRemote = false;
range.AllowDeliveryFromRemoteToLocal = false;
range.AllowDeliveryFromRemoteToRemote = false;
range.Save();
Account account1 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
var smtpClientSimulator = new SmtpClientSimulator();
string result1 = "", result2 = "", result3 = "", result4 = "";
CustomAsserts.Throws<DeliveryFailedException>(() => smtpClientSimulator.Send(account1.Address, account1.Address, "Mail 1", "Mail 1", out result1));
CustomAsserts.Throws<DeliveryFailedException>(() => smtpClientSimulator.Send(account1.Address, "*****@*****.**", "Mail 1", "Mail 1", out result2));
CustomAsserts.Throws<DeliveryFailedException>(() => smtpClientSimulator.Send("*****@*****.**", account1.Address, "Mail 1", "Mail 1", out result3));
CustomAsserts.Throws<DeliveryFailedException>(() => smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "Mail 1", "Mail 1",
out result4));
Assert.IsTrue(result1.Contains("550 Delivery is not allowed to this address."));
Assert.IsTrue(result2.Contains("550 Delivery is not allowed to this address."));
Assert.IsTrue(result3.Contains("550 Delivery is not allowed to this address."));
Assert.IsTrue(result4.Contains("550 Delivery is not allowed to this address."));
}
public void ConfirmSingleReturnPathAfterAccountForward()
{
// Create a test account
// Fetch the default domain
Account oAccount1 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
Account oAccount2 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
oAccount1.ForwardAddress = oAccount2.Address;
oAccount1.ForwardEnabled = true;
oAccount1.Save();
// Send a message...
var smtpClientSimulator = new SmtpClientSimulator();
smtpClientSimulator.Send("*****@*****.**", oAccount1.Address, "Test message", "This is the body");
CustomAsserts.AssertRecipientsInDeliveryQueue(0);
_application.SubmitEMail();
// Wait for the auto-reply.
string text = Pop3ClientSimulator.AssertGetFirstMessageText(oAccount2.Address, "test");
Assert.IsFalse(text.Contains("Return-Path: [email protected]"));
Assert.IsFalse(text.Contains("Return-Path: [email protected]"));
Assert.IsTrue(text.Contains("Return-Path: [email protected]"));
}
public void SmtpServerNOTSupportingStartTls_StartTlsRequired()
{
Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
// Set up a server listening on port 250 which accepts email for [email protected]
var deliveryResults = new Dictionary<string, int>();
deliveryResults["*****@*****.**"] = 250;
int smtpServerPort = TestSetup.GetNextFreePort();
using (var server = new SmtpServerSimulator(1, smtpServerPort, eConnectionSecurity.eCSNone))
{
server.SetCertificate(SslSetup.GetCertificate());
server.AddRecipientResult(deliveryResults);
server.StartListen();
Route route = TestSetup.AddRoutePointingAtLocalhost(1, smtpServerPort, true, eConnectionSecurity.eCSSTARTTLSRequired);
var smtpClient = new SmtpClientSimulator();
smtpClient.Send(account.Address, "*****@*****.**", "Test", "Test message");
CustomAsserts.AssertRecipientsInDeliveryQueue(0);
// This should now be processed via the rule -> route -> external server we've set up.
server.WaitForCompletion();
var msg = Pop3ClientSimulator.AssertGetFirstMessageText("*****@*****.**", "test");
Assert.IsTrue(msg.Contains("Server does not support STARTTLS"));
}
}
public void TestNestedOrSearch()
{
Application application = SingletonProvider<TestSetup>.Instance.GetApp();
Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
// Send a message to this account.
var smtpClientSimulator = new SmtpClientSimulator();
smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "Search test", "This is a test of IMAP Search");
ImapClientSimulator.AssertMessageCount(oAccount.Address, "test", "Inbox", 1);
var oSimulator = new ImapClientSimulator();
string sWelcomeMessage = oSimulator.Connect();
oSimulator.Logon("*****@*****.**", "test");
oSimulator.SelectFolder("INBOX");
string result =
oSimulator.SendSingleCommand("A4 SEARCH ALL OR OR SINCE 28-May-2008 SINCE 28-May-2008 SINCE 28-May-2008");
Assert.IsTrue(result.StartsWith("* SEARCH 1"), result);
result = oSimulator.SendSingleCommand("A4 SEARCH ALL OR SMALLER 1 LARGER 10000");
Assert.IsTrue(result.StartsWith("* SEARCH\r\n"), result);
result = oSimulator.SendSingleCommand("A4 SEARCH ALL OR OR SMALLER 1 LARGER 10000 SMALLER 10000");
Assert.IsTrue(result.StartsWith("* SEARCH 1\r\n"), result);
}
public void DoNotUseStartTlsIfNotEnabledAndNotAvailable()
{
// No valid recipients...
var deliveryResults = new Dictionary<string, int>();
deliveryResults["*****@*****.**"] = 250;
int smtpServerPort = TestSetup.GetNextFreePort();
using (var server = new SmtpServerSimulator(1, smtpServerPort, eConnectionSecurity.eCSNone))
{
server.AddRecipientResult(deliveryResults);
server.StartListen();
Route route = TestSetup.AddRoutePointingAtLocalhost(1, smtpServerPort, false, eConnectionSecurity.eCSNone);
// Send message to this route.
var smtp = new SmtpClientSimulator();
smtp.Send("*****@*****.**", "*****@*****.**", "Test", "Test message");
// Wait for the client to disconnect.
server.WaitForCompletion();
CustomAsserts.AssertRecipientsInDeliveryQueue(0, false);
Assert.IsNotNullOrEmpty(server.MessageData);
Assert.IsFalse(LogHandler.DefaultLogContains("220 Ready to start TLS"));
}
}
public static void StaticSend(string sFrom, string recipient, string sSubject, string sBody)
{
var messageRecipients = new List<string>();
messageRecipients.Add(recipient);
var oSimulator = new SmtpClientSimulator();
oSimulator.Send(sFrom, messageRecipients, sSubject, sBody);
}
public void TestCaseInsensitivtyAccount()
{
Account testAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
var smtpClientSimulator = new SmtpClientSimulator();
string upperCase = testAccount.Address.ToUpper();
smtpClientSimulator.Send("*****@*****.**", upperCase, "test mail", "test body");
Pop3ClientSimulator.AssertMessageCount("*****@*****.**", "test", 1);
}
public static void StaticSend(string sFrom, string recipient, string sSubject, string sBody)
{
var messageRecipients = new List <string>();
messageRecipients.Add(recipient);
var oSimulator = new SmtpClientSimulator();
oSimulator.Send(sFrom, messageRecipients, sSubject, sBody);
}
public void ItShouldBePossibleToEnableSslV3()
{
SetSslVersions(true, false, false, false);
var smtpClientSimulator = new SmtpClientSimulator(true, SslProtocols.Ssl3, 25001, IPAddress.Parse("127.0.0.1"));
string errorMessage;
smtpClientSimulator.Send(false, _account.Address, "test", _account.Address, _account.Address, "Test", "test", out errorMessage);
var message = Pop3ClientSimulator.AssertGetFirstMessageText(_account.Address, "test");
Assert.IsTrue(message.Contains("version=SSLv3"), message);
}
public void WhenSSL3IsDisabledTLSShouldWork()
{
SetSslVersions(false, true, true, true);
var smtpClientSimulator = new SmtpClientSimulator(true, SslProtocols.Tls, 25001, IPAddress.Parse("127.0.0.1"));
string errorMessage;
smtpClientSimulator.Send(false, _account.Address, "test", _account.Address, _account.Address, "Test", "test", out errorMessage);
var message = Pop3ClientSimulator.AssertGetFirstMessageText(_account.Address, "test");
Assert.IsTrue(message.Contains("version=TLSv1"), message);
}
public void TestESMTPAInHeader()
{
string errorMessage;
var client = new SmtpClientSimulator();
client.Send(false, _account.Address, "test", _account.Address, _account.Address, "Test", "Test", out errorMessage);
var message = Pop3ClientSimulator.AssertGetFirstMessageText(_account.Address, "test");
Assert.IsTrue(message.Contains("ESMTPA\r\n"));
}
public void UnsupportedParameterInMailFrom()
{
var smtpConn = new SmtpClientSimulator();
smtpConn.Connect();
smtpConn.Receive();
smtpConn.SendAndReceive("EHLO example.com\r\n");
var response = smtpConn.SendAndReceive("MAIL FROM: [email protected] A=B\r\n");
Assert.AreEqual("550 Unsupported ESMTP extension: A=B\r\n", response);
}
public void DeliveryShouldSucceedAfterClearingDeliveryQueue()
{
SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
_application.GlobalObjects.DeliveryQueue.Clear();
Assert.IsTrue(LogHandler.DefaultLogContains("Delivery queue cleared."));
var smtpClientSimulator = new SmtpClientSimulator();
smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "INBOX", "Mirror test message");
Pop3ClientSimulator.AssertMessageCount("*****@*****.**", "test", 1);
}
public void MessageHeaderShouldBeValidAfterSAHasRun()
{
// Send a messages to this account.
var smtpClient = new SmtpClientSimulator();
smtpClient.Send(account.Address, account.Address, "SA test",
"This is a test message with spam.\r\n XJS*C4JDBQADN1.NSBN3*2IDNEN*GTUBE-STANDARD-ANTI-UBE-TEST-EMAIL*C.34X.");
string fullMessage = Pop3ClientSimulator.AssertGetFirstMessageText(account.Address, "test");
string messageHeader = fullMessage.Substring(0, fullMessage.IndexOf("\r\n\r\n"));
Assert.IsTrue(messageHeader.Contains("Received:"));
Assert.IsTrue(messageHeader.Contains("Return-Path:"));
Assert.IsTrue(messageHeader.Contains("From:"));
Assert.IsTrue(messageHeader.Contains("Subject: ThisIsSpam"));
}
public void TestEmptyPassword()
{
Account account1 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "");
string message;
var sim = new Pop3ClientSimulator();
Assert.IsFalse(sim.ConnectAndLogon(account1.Address, "", out message));
var simIMAP = new ImapClientSimulator();
Assert.IsFalse(simIMAP.ConnectAndLogon(account1.Address, "", out message));
Assert.AreEqual("A01 NO Invalid user name or password.\r\n", message);
var simSMTP = new SmtpClientSimulator();
CustomAsserts.Throws<AuthenticationException>(() => simSMTP.ConnectAndLogon("dGVzdEB0ZXN0LmNvbQ==", "", out message));
Assert.AreEqual("535 Authentication failed. Restarting authentication process.\r\n", message);
}
public void ActionAccountRuleMoveToExistingPublicFolder()
{
Application application = SingletonProvider<TestSetup>.Instance.GetApp();
// Add an account
Account account1 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
IMAPFolders publicFolders = _settings.PublicFolders;
IMAPFolder folder = publicFolders.Add("Share1");
folder.Save();
IMAPFolderPermission permission = folder.Permissions.Add();
permission.PermissionAccountID = account1.ID;
permission.PermissionType = eACLPermissionType.ePermissionTypeUser;
permission.set_Permission(eACLPermission.ePermissionInsert, true);
permission.set_Permission(eACLPermission.ePermissionRead, true);
permission.set_Permission(eACLPermission.ePermissionExpunge, true);
permission.Save();
Rule oRule = account1.Rules.Add();
oRule.Name = "Criteria test";
oRule.Active = true;
RuleCriteria oRuleCriteria = oRule.Criterias.Add();
oRuleCriteria.UsePredefined = true;
oRuleCriteria.PredefinedField = eRulePredefinedField.eFTMessageSize;
oRuleCriteria.MatchType = eRuleMatchType.eMTGreaterThan;
oRuleCriteria.MatchValue = "0";
oRuleCriteria.Save();
// Add action
RuleAction oRuleAction = oRule.Actions.Add();
oRuleAction.Type = eRuleActionType.eRAMoveToImapFolder;
oRuleAction.IMAPFolder = "#public.Share1";
oRuleAction.Save();
// Save the rule in the database
oRule.Save();
var smtpClientSimulator = new SmtpClientSimulator();
// Spam folder
smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "SomeString",
"Detta ska hamna i public folder.");
ImapClientSimulator.AssertMessageCount("*****@*****.**", "test", "#public.Share1", 1);
}
public void RoutesShouldConsolidateRecipients()
{
// Set up a server listening on port 250 which accepts email for [email protected]
var deliveryResults = new Dictionary<string, int>();
deliveryResults["*****@*****.**"] = 250;
deliveryResults["*****@*****.**"] = 250;
deliveryResults["*****@*****.**"] = 250;
deliveryResults["*****@*****.**"] = 250;
int smtpServerPort = TestSetup.GetNextFreePort();
using (var server = new SmtpServerSimulator(1, smtpServerPort))
{
server.AddRecipientResult(deliveryResults);
server.StartListen();
// Add a route pointing at localhost
Route route = _settings.Routes.Add();
route.DomainName = "test.com";
route.TargetSMTPHost = "localhost";
route.TargetSMTPPort = smtpServerPort;
route.NumberOfTries = 1;
route.MinutesBetweenTry = 5;
route.TreatRecipientAsLocalDomain = true;
route.TreatSenderAsLocalDomain = true;
route.AllAddresses = true;
route.Save();
var smtpClient = new SmtpClientSimulator();
var recipients = new List<string>()
{
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
"*****@*****.**"
};
smtpClient.Send("*****@*****.**", recipients, "Test", "Test message");
CustomAsserts.AssertRecipientsInDeliveryQueue(0);
server.WaitForCompletion();
Assert.IsTrue(server.MessageData.Contains("Test message"));
Assert.AreEqual(deliveryResults.Count, server.RcptTosReceived);
}
}
public void TestSenderAsExternalDomainSendToLocalAccountFail()
{
int smtpServerPort = TestSetup.GetNextFreePort();
Route route = TestSetup.AddRoutePointingAtLocalhost(1, smtpServerPort, false);
route.TreatSenderAsLocalDomain = false;
route.Save();
SecurityRange range =
SingletonProvider<TestSetup>.Instance.GetApp().Settings.SecurityRanges.get_ItemByName("My computer");
range.RequireSMTPAuthExternalToLocal = true;
range.Save();
Account account1 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
var smtpClientSimulator = new SmtpClientSimulator();
string result;
CustomAsserts.Throws<DeliveryFailedException>(() => smtpClientSimulator.Send("*****@*****.**", account1.Address, "Mail 1", "Mail 1", out result));
}
public void TestESMTPSAInHeader()
{
try
{
var smtpClientSimulator = new SmtpClientSimulator(false, 25002);
string errorMessage;
smtpClientSimulator.Send(true, _account.Address, "test", _account.Address, _account.Address, "Test", "test",
out errorMessage);
var message = Pop3ClientSimulator.AssertGetFirstMessageText(_account.Address, "test");
Assert.IsTrue(message.Contains("ESMTPSA\r\n"));
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
}
public void TestAliases()
{
// Fetch default domain
// Create another account
Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
// Add aliases
SingletonProvider<TestSetup>.Instance.AddAlias(_domain, "*****@*****.**", "*****@*****.**");
SingletonProvider<TestSetup>.Instance.AddAlias(_domain, "*****@*****.**", "*****@*****.**");
var smtpClientSimulator = new SmtpClientSimulator();
// Spam folder
smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "Mail 1", "Mail 1");
smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "Mail 2", "Mail 2");
smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "Mail 3", "Mail 3");
ImapClientSimulator.AssertMessageCount("*****@*****.**", "test", "Inbox", 3);
}
public void RecipientNotInListShouldReturnError()
{
// Add a route pointing at localhost
Route route = _settings.Routes.Add();
route.DomainName = "test.com";
route.TargetSMTPHost = "localhost";
route.TargetSMTPPort = 255;
route.NumberOfTries = 1;
route.MinutesBetweenTry = 5;
route.TreatRecipientAsLocalDomain = true;
route.TreatSenderAsLocalDomain = true;
route.AllAddresses = false; // only to recipients in list.
route.Save();
var smtpClient = new SmtpClientSimulator();
string resultMessage = "";
CustomAsserts.Throws<DeliveryFailedException>(() => smtpClient.Send("*****@*****.**", "*****@*****.**", "Test", "Test message", out resultMessage));
Assert.AreEqual("550 Recipient not in route list.", resultMessage);
}
public void TestCipherInfoInReceivedHeader()
{
try
{
var smtpClientSimulator = new SmtpClientSimulator(false, 25002);
string errorMessage;
smtpClientSimulator.Send(true, _account.Address, "test", _account.Address, _account.Address, "Test", "test",
out errorMessage);
var message = Pop3ClientSimulator.AssertGetFirstMessageText(_account.Address, "test");
Assert.IsTrue(message.Contains("version=TLS"));
Assert.IsTrue(message.Contains("cipher="));
Assert.IsTrue(message.Contains("bits="));
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
}
public void SslV2ShouldBeDisabled()
{
SetSslVersions(true, true, true, true);
var smtpClientSimulator = new SmtpClientSimulator(true, SslProtocols.Ssl2, 25001, null);
try
{
string errorMessage;
smtpClientSimulator.Send(false, _account.Address, "test", _account.Address, _account.Address, "Test", "test", out errorMessage);
}
catch (System.IO.IOException)
{
// expected
}
RetryHelper.TryAction(TimeSpan.FromSeconds(10), () =>
{
var defaultLog = LogHandler.ReadCurrentDefaultLog();
Assert.IsTrue(defaultLog.Contains("unknown protocol"));
});
}
public void TestMirror()
{
// Create a test account
// Fetch the default domain
Account oAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
Account oAccount2 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
_settings.MirrorEMailAddress = "*****@*****.**";
_settings.AddDeliveredToHeader = true;
// Send 5 messages to this account.
var smtpClientSimulator = new SmtpClientSimulator();
for (int i = 0; i < 5; i++)
smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "INBOX", "Mirror test message");
// Check using POP3 that 5 messages exists.
Pop3ClientSimulator.AssertMessageCount("*****@*****.**", "test", 5);
string message = Pop3ClientSimulator.AssertGetFirstMessageText(oAccount2.Address, "test");
Assert.IsTrue(message.Contains("Delivered-To: [email protected]"));
}
public void SurblTestRealWorldBody1()
{
LogHandler.DeleteCurrentDefaultLog();
// Create a test account
// Fetch the default domain
Account oAccount1 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test");
// Disallow incorrect line endings.
_antiSpam.SpamMarkThreshold = 1;
_antiSpam.SpamDeleteThreshold = 100;
_antiSpam.AddHeaderReason = true;
_antiSpam.AddHeaderSpam = true;
_antiSpam.PrependSubject = true;
_antiSpam.PrependSubjectText = "ThisIsSpam";
// Enable SURBL.
SURBLServer oSURBLServer = _antiSpam.SURBLServers[0];
oSURBLServer.Active = true;
oSURBLServer.Score = 5;
oSURBLServer.Save();
// Send a messages to this account.
var smtpClientSimulator = new SmtpClientSimulator();
smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "SURBL-Match", TestResources.SecuniaBody1);
string sMessageContents = Pop3ClientSimulator.AssertGetFirstMessageText(oAccount1.Address, "test");
Assert.IsFalse(sMessageContents.Contains("X-hMailServer-Spam"), "Spam message not detected as spam");
oSURBLServer.Active = false;
oSURBLServer.Save();
Assert.IsTrue(LogHandler.DefaultLogContains("SURBL: 2 unique addresses found."));
Assert.IsTrue(LogHandler.DefaultLogContains("SURBL: Found URL: secunia.com"));
Assert.IsFalse(LogHandler.DefaultLogContains("SURBL: Found URL: ecunia.com"));
Assert.IsTrue(LogHandler.DefaultLogContains("SURBL: Lookup: secunia.com.multi.surbl.org"));
Assert.IsTrue(LogHandler.DefaultLogContains("SURBL: Lookup: ubuntu.com.multi.surbl.org"));
}
public void TestAuthFailurePasswordInBounce()
{
Assert.AreEqual(0, _status.UndeliveredMessages.Length);
// No valid recipients...
var deliveryResults = new Dictionary<string, int>();
deliveryResults["*****@*****.**"] = 250;
int smtpServerPort = TestSetup.GetNextFreePort();
using (var server = new SmtpServerSimulator(1, smtpServerPort))
{
server.AddRecipientResult(deliveryResults);
server.SimulatedError = SimulatedErrorType.ForceAuthenticationFailure;
server.StartListen();
// Add a route so we can connect to localhost.
Route route = TestSetup.AddRoutePointingAtLocalhost(5, smtpServerPort, false);
route.RelayerRequiresAuth = true;
route.RelayerAuthUsername = "******";
route.SetRelayerAuthPassword("MySecretPassword");
// Send message to this route.
var smtp = new SmtpClientSimulator();
var recipients = new List<string>();
recipients.Add("*****@*****.**");
smtp.Send("*****@*****.**", recipients, "Test", "Test message");
// Wait for the client to disconnect.
server.WaitForCompletion();
CustomAsserts.AssertRecipientsInDeliveryQueue(0);
string messageText = Pop3ClientSimulator.AssertGetFirstMessageText(_account.Address, "test");
Assert.IsFalse(messageText.Contains("MySecretPassword"));
Assert.IsTrue(messageText.Contains("<Password removed>"));
}
}
public static void StaticSendRaw(string sFrom, string list, string sBody)
{
var simulator = new SmtpClientSimulator();
simulator.SendRaw(sFrom, list, sBody);
}
public static void StaticSendRaw(string sFrom, string recipient, string sBody)
{
var oSimulator = new SmtpClientSimulator();
oSimulator.SendRaw(sFrom, recipient, sBody);
}
public static void StaticSend(string sFrom, List <string> lstRecipients, string sSubject, string sBody)
{
var oSimulator = new SmtpClientSimulator();
oSimulator.Send(sFrom, lstRecipients, sSubject, sBody);
}
