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 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 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 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 void TestDeliverToMyselfOnLocalPortAfterChangedLocalPort() { TCPIPPorts oPorts = _application.Settings.TCPIPPorts; for (int i = 0; i < oPorts.Count; i++) { TCPIPPort oTestPort = oPorts[i]; if (oTestPort.Protocol == eSessionType.eSTIMAP) oTestPort.PortNumber = 14300; else if (oTestPort.Protocol == eSessionType.eSTSMTP) oTestPort.PortNumber = 11000; else if (oTestPort.Protocol == eSessionType.eSTPOP3) oTestPort.PortNumber = 2500; oTestPort.Save(); } _application.Stop(); _application.Start(); // Set up a server and start listening. var deliveryResults = new Dictionary<string, int>(); deliveryResults["*****@*****.**"] = 250; int smtpServerPort = TestSetup.GetNextFreePort(); using (var server = new SmtpServerSimulator(1, smtpServerPort)) { server.AddRecipientResult(deliveryResults); server.StartListen(); // Add a route so we can connect to localhost. TestSetup.AddRoutePointingAtLocalhost(5, smtpServerPort, false); // Send message to this route. var sim = new SmtpClientSimulator(false, 11000); sim.Send("*****@*****.**", "*****@*****.**", "Test", "Test message"); // Wait for the client to disconnect. server.WaitForCompletion(); CustomAsserts.AssertRecipientsInDeliveryQueue(0, false); Assert.IsTrue(server.MessageData.Contains("Test message")); } oPorts.SetDefault(); _application.Stop(); _application.Start(); }
public void RoutesShouldSupportWildcardDomain() { // 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)) { server.AddRecipientResult(deliveryResults); server.StartListen(); // Add a route pointing at localhost Route route = _settings.Routes.Add(); route.DomainName = "*.example.com"; route.TargetSMTPHost = "localhost"; route.TargetSMTPPort = smtpServerPort; route.NumberOfTries = 1; route.MinutesBetweenTry = 5; route.TreatRecipientAsLocalDomain = true; route.TreatSenderAsLocalDomain = true; route.AllAddresses = true; route.Save(); // Make sure only the specific user is valid. RouteAddress routeAddress = route.Addresses.Add(); routeAddress.Address = "user@" + _domain.Name; routeAddress.Save(); var smtpClient = new SmtpClientSimulator(); smtpClient.Send("*****@*****.**", "*****@*****.**", "Test", "Test message"); CustomAsserts.AssertRecipientsInDeliveryQueue(0); server.WaitForCompletion(); Assert.IsTrue(server.MessageData.Contains("Test message")); } }
public void TestSMTPClient() { Account account1 = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test"); Assert.AreEqual(0, _status.UndeliveredMessages.Length); // No valid recipients... var deliveryResults = new Dictionary<string, int>(); deliveryResults["*****@*****.**"] = 550; int smtpServerPort = TestSetup.GetNextFreePort(); using (var server = new SmtpServerSimulator(1, smtpServerPort)) { server.AddRecipientResult(deliveryResults); server.StartListen(); // Add a route so we can connect to localhost. AddRoutePointingAtLocalhostWithAuth(0, smtpServerPort); // Send message to this route. var smtp = new SmtpClientSimulator(); smtp.Send("*****@*****.**", "*****@*****.**", "Test", "Test message"); CustomAsserts.AssertRecipientsInDeliveryQueue(0); string undeliveredMessages = _status.UndeliveredMessages; // Wait for the client to disconnect. server.WaitForCompletion(); CustomAsserts.AssertRecipientsInDeliveryQueue(0); EnsureNoPassword(); } }
public void TestDeliveryAttempts() { // Add an account Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test"); Account adminAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test"); // Set up a rule to forward from account1 to 2 and 3. Rule oRule = _application.Rules.Add(); oRule.Name = "Criteria test"; oRule.Active = true; oRule.UseAND = true; RuleCriteria oRuleCriteria = oRule.Criterias.Add(); oRuleCriteria.UsePredefined = true; oRuleCriteria.PredefinedField = eRulePredefinedField.eFTDeliveryAttempts; oRuleCriteria.MatchType = eRuleMatchType.eMTEquals; oRuleCriteria.MatchValue = "2"; oRuleCriteria.Save(); // The second time we try to deliver an email, forward a copy to the admin! RuleAction oRuleAction = oRule.Actions.Add(); oRuleAction.Type = eRuleActionType.eRAForwardEmail; oRuleAction.To = adminAccount.Address; oRuleAction.Save(); // And then delete it. oRuleAction = oRule.Actions.Add(); oRuleAction.Type = eRuleActionType.eRADeleteEmail; oRuleAction.Save(); // Save the rule in the database oRule.Save(); var deliveryResults = new Dictionary<string, int>(); deliveryResults["*****@*****.**"] = 452; int smtpServerPort = TestSetup.GetNextFreePort(); using (var smtpServer = new SmtpServerSimulator(1, smtpServerPort)) { smtpServer.AddRecipientResult(deliveryResults); smtpServer.StartListen(); // Add a route so we can connect to localhost. TestSetup.AddRoutePointingAtLocalhost(2, smtpServerPort, false); var smtpClientSimulator = new SmtpClientSimulator(); // Test to send the message to account 1. Make sure a copy is created by this rule. smtpClientSimulator.Send(account.Address, new List<string> {"*****@*****.**"}, "Test", "Test message."); smtpServer.WaitForCompletion(); } CustomAsserts.AssertRecipientsInDeliveryQueue(0, true); string first = Pop3ClientSimulator.AssertGetFirstMessageText(adminAccount.Address, "test"); Assert.IsTrue(first.Contains("X-hMailServer-LoopCount: 1"), first); Pop3ClientSimulator.AssertMessageCount(account.Address, "test", 0); }
public void TestMultipleHostsLimitMXHosts() { _settings.MaxNumberOfMXHosts = 1; // 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.StartListen(); // Add a route so we can connect to localhost. Route route = TestSetup.AddRoutePointingAtLocalhostMultipleHosts(2, smtpServerPort); // Send message to this route. var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); recipients.Add("*****@*****.**"); SmtpClientSimulator.StaticSend("*****@*****.**", "*****@*****.**", "Test", "Test"); // Wait for the client to disconnect. server.WaitForCompletion(); string log = LogHandler.ReadCurrentDefaultLog(); Assert.IsTrue(log.Contains("Truncating MX server list.")); } }
public void TestFailureAfterReceivedHelloBanner() { _application.Settings.SMTPNoOfTries = 3; _application.Settings.SMTPMinutesBetweenTry = 60; 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.DisconnectAfterSessionStart; server.StartListen(); // Add a route so we can connect to localhost. TestSetup.AddRoutePointingAtLocalhost(1, smtpServerPort, false); // Send message to this route. var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); recipients.Add("*****@*****.**"); smtp.Send(_account.Address, recipients, "Test", "Test message"); // Wait for the client to disconnect. server.WaitForCompletion(); // Force the message to be bounced. CustomAsserts.AssertRecipientsInDeliveryQueue(0, true); string bounce = Pop3ClientSimulator.AssertGetFirstMessageText(_account.Address, "test"); Assert.IsTrue(bounce.Contains("*****@*****.**")); Assert.IsTrue(bounce.Contains("Remote server closed connection.")); Assert.IsTrue(bounce.Contains("Tried 1 time(s)")); } }
public void TestFailureAfterDelivery() { _application.Settings.SMTPNoOfTries = 3; _application.Settings.SMTPMinutesBetweenTry = 60; 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.QuitResult = 421; server.StartListen(); // Add a route so we can connect to localhost. TestSetup.AddRoutePointingAtLocalhost(5, smtpServerPort, false); // Send message to this route. var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); recipients.Add("*****@*****.**"); smtp.Send("*****@*****.**", recipients, "Test", "test of error after accepted delivery"); // Wait for the client to disconnect. server.WaitForCompletion(); CustomAsserts.AssertRecipientsInDeliveryQueue(0); Assert.IsTrue(server.MessageData.Contains("test of error after accepted delivery")); } }
public void TestDeliverySuccessSingleRecipientMissingQuitResponse() { 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.StartListen(); server.SimulatedError = SimulatedErrorType.DisconnectWithoutReplyOnQuit; // Add a route so we can connect to localhost. TestSetup.AddRoutePointingAtLocalhost(5, smtpServerPort, false); // Send message to this route. var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); recipients.Add("*****@*****.**"); smtp.Send("*****@*****.**", recipients, "Test", "DeliverySuccessNoQuitResponse"); // Wait for the client to disconnect. server.WaitForCompletion(); CustomAsserts.AssertRecipientsInDeliveryQueue(0, false); Assert.IsTrue(server.MessageData.Contains("DeliverySuccessNoQuitResponse")); } }
public void TestDeliverySuccess50Recipients() { Assert.AreEqual(0, _status.UndeliveredMessages.Length); // No valid recipients... var deliveryResults = new Dictionary<string, int>(); for (int i = 0; i < 50; i++) deliveryResults["user" + i.ToString() + "@dummy-example.com"] = 250; int smtpServerPort = TestSetup.GetNextFreePort(); using (var server = new SmtpServerSimulator(1, smtpServerPort)) { server.AddRecipientResult(deliveryResults); server.StartListen(); // Add a route so we can conenct to localhost. TestSetup.AddRoutePointingAtLocalhost(5, smtpServerPort, false); // Send message to this route. var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); for (int i = 0; i < 50; i++) recipients.Add("user" + i.ToString() + "@dummy-example.com"); smtp.Send("*****@*****.**", recipients, "Test", "Test message"); // Wait for the client to disconnect. server.WaitForCompletion(); CustomAsserts.AssertRecipientsInDeliveryQueue(0, false); Assert.IsTrue(server.MessageData.Contains("Test message")); } }
public void TestDeliverToServerNotSupportingHELO() { Assert.AreEqual(0, _status.UndeliveredMessages.Length); var deliveryResults = new Dictionary<string, int>() { {"*****@*****.**", 250} }; int smtpServerPort = TestSetup.GetNextFreePort(); using (var server = new SmtpServerSimulator(1, smtpServerPort)) { server.ServerSupportsHelo = false; server.AddRecipientResult(deliveryResults); server.StartListen(); // Add a route so we can conenct to localhost. TestSetup.AddRoutePointingAtLocalhost(1, smtpServerPort, false, eConnectionSecurity.eCSNone); // Send message to this route. SmtpClientSimulator.StaticSend("*****@*****.**", "*****@*****.**", "Test", "Test message"); // Wait for the client to disconnect. server.WaitForCompletion(); CustomAsserts.AssertRecipientsInDeliveryQueue(0, true); var msg = Pop3ClientSimulator.AssertGetFirstMessageText("*****@*****.**", "test"); Assert.IsTrue(msg.Contains("Remote server replied: 550 Command HELO not recognized.")); } }
public void TestDeliverToServerNotSupportingEHLO() { Assert.AreEqual(0, _status.UndeliveredMessages.Length); var deliveryResults = new Dictionary<string, int>() { {"*****@*****.**", 250} }; int smtpServerPort = TestSetup.GetNextFreePort(); using (var server = new SmtpServerSimulator(1, smtpServerPort)) { server.ServerSupportsEhlo = false; server.AddRecipientResult(deliveryResults); server.StartListen(); // Add a route so we can conenct to localhost. TestSetup.AddRoutePointingAtLocalhost(1, smtpServerPort, false, eConnectionSecurity.eCSNone); SmtpClientSimulator.StaticSend("*****@*****.**", "*****@*****.**", "Test", "Test message"); // Wait for the client to disconnect. server.WaitForCompletion(); CustomAsserts.AssertRecipientsInDeliveryQueue(0, false); Assert.IsTrue(server.MessageData.Contains("Test message")); } }
public void DomainAliasesShouldNotRewriteRecipientList() { DomainAlias oDA = _domain.DomainAliases.Add(); oDA.AliasName = "dummy-example.com"; oDA.Save(); 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)) { server.AddRecipientResult(deliveryResults); server.StartListen(); Route route = TestSetup.AddRoutePointingAtLocalhost(1, smtpServerPort, true, eConnectionSecurity.eCSNone); // Now send a message from [email protected] to [email protected]. // Error scenario: // In the recipientlist, otherdomain.com gets rewritten to test.com // since there's a domain alias named otherdomain.co on the domain // test.com. // // This should not happen. Otherdomain.com is an alias for test.com, // but we shouldn't actually modify the recipient address just because // of this. var smtpClient = new SmtpClientSimulator(); smtpClient.Send(account.Address, "*****@*****.**", "Test", "Test message"); CustomAsserts.AssertRecipientsInDeliveryQueue(0); Pop3ClientSimulator.AssertMessageCount(account.Address, "test", 0); // This should now be processed via the rule -> route -> external server we've set up. server.WaitForCompletion(); Assert.IsTrue(server.MessageData.Contains("Test message")); } }
public void SmtpRelayShouldConsolidateRecipients() { // 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)) { _application.Settings.SMTPRelayer = "localhost"; _application.Settings.SMTPRelayerPort = smtpServerPort; server.AddRecipientResult(deliveryResults); server.StartListen(); var smtpClient = new SmtpClientSimulator(); var recipients = new List<string>() { "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**" }; Account senderAccount = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test"); smtpClient.Send(senderAccount.Address, recipients, "Test", "Test message"); CustomAsserts.AssertRecipientsInDeliveryQueue(0); server.WaitForCompletion(); Assert.IsTrue(server.MessageData.Contains("Test message")); Assert.AreEqual(deliveryResults.Count, server.RcptTosReceived); } }
public void TestFatalDeliveryFailure() { _application.Settings.Logging.Enabled = true; _application.Settings.Logging.LogSMTP = true; _application.Settings.Logging.LogTCPIP = true; _application.Settings.Logging.LogDebug = true; Assert.AreEqual(0, _status.UndeliveredMessages.Length); // No valid recipients... var deliveryResults = new Dictionary<string, int>(); deliveryResults["*****@*****.**"] = 550; int smtpServerPort = TestSetup.GetNextFreePort(); using (var server = new SmtpServerSimulator(1, smtpServerPort)) { server.AddRecipientResult(deliveryResults); server.StartListen(); // Add a route so we can conenct to localhost. TestSetup.AddRoutePointingAtLocalhost(0, smtpServerPort, false); // Send message to this route. var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); recipients.Add("*****@*****.**"); smtp.Send("*****@*****.**", recipients, "Test", "Test message"); string undeliveredMessages = _status.UndeliveredMessages; // Wait for the client to disconnect. server.WaitForCompletion(); // wait for the message to be delivered. for (int i = 1; i <= 40; i++) { Assert.IsFalse(i == 40); if (_status.UndeliveredMessages.Contains("\[email protected]") || _status.UndeliveredMessages.Length == 0) break; Thread.Sleep(250); } CustomAsserts.AssertRecipientsInDeliveryQueue(0, true); string bounceMessage = Pop3ClientSimulator.AssertGetFirstMessageText(_account.Address, "test"); Assert.IsTrue(bounceMessage.Contains("Remote server (127.0.0.1) issued an error.")); Assert.IsTrue(bounceMessage.Contains("550 [email protected]")); } }
public void TestSendExternalToExternalPermitted() { SecurityRange range = SingletonProvider<TestSetup>.Instance.GetApp().Settings.SecurityRanges.get_ItemByName("My computer"); range.RequireSMTPAuthExternalToExternal = false; range.Save(); // 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)) { server.AddRecipientResult(deliveryResults); server.StartListen(); Route route = TestSetup.AddRoutePointingAtLocalhost(1, smtpServerPort, false, eConnectionSecurity.eCSNone); var smtpClientSimulator = new SmtpClientSimulator(); smtpClientSimulator.Send("*****@*****.**", "*****@*****.**", "Mail 1", "Test message"); // This should now be processed via the rule -> route -> external server we've set up. server.WaitForCompletion(); Assert.IsTrue(server.MessageData.Contains("Test message")); } }
public void TestLargeMessageSuccess() { 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.StartListen(); // Add a route so we can connect to localhost. TestSetup.AddRoutePointingAtLocalhost(5, smtpServerPort, false); // Send message to this route. var messageBody = TestSetup.CreateLargeDummyMailBody(); var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); recipients.Add("*****@*****.**"); smtp.Send("*****@*****.**", recipients, "Test", messageBody); // Wait for the client to disconnect. server.WaitForCompletion(); Assert.IsTrue(server.Conversation.Contains("\r\nDATA\r\n")); CustomAsserts.AssertRecipientsInDeliveryQueue(0, false); Assert.IsTrue(server.MessageData.Contains(messageBody)); } }
public void ActionSendUsingRoute() { int smtpServerPort = TestSetup.GetNextFreePort(); // add an account to send from Account account = SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test"); // Add a route so we can conenct to localhost. Route route = TestSetup.AddRoutePointingAtLocalhost(5, smtpServerPort, false); // Add a global send-using-route rule Rule oRule = _application.Rules.Add(); oRule.Name = "Send using route"; oRule.Active = true; RuleCriteria oRuleCriteria = oRule.Criterias.Add(); oRuleCriteria.UsePredefined = false; oRuleCriteria.HeaderField = "Subject"; oRuleCriteria.MatchType = eRuleMatchType.eMTContains; oRuleCriteria.MatchValue = "TestString"; oRuleCriteria.Save(); // Add action RuleAction oRuleAction = oRule.Actions.Add(); oRuleAction.Type = eRuleActionType.eRASendUsingRoute; oRuleAction.RouteID = route.ID; oRuleAction.Save(); oRule.Save(); // Send message and confirm that the route does not affect it. var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); recipients.Add("*****@*****.**"); smtp.Send("*****@*****.**", recipients, "Test", "Test message"); string message = Pop3ClientSimulator.AssertGetFirstMessageText(account.Address, "test"); Assert.IsTrue(message.Contains("Test message")); // Send a message and confirm that the rule affects it. var deliveryResults = new Dictionary<string, int>(); deliveryResults["*****@*****.**"] = 550; using (var server = new SmtpServerSimulator(1, smtpServerPort)) { server.AddRecipientResult(deliveryResults); server.StartListen(); // Send the actual message recipients = new List<string>(); recipients.Add("*****@*****.**"); smtp.Send("*****@*****.**", recipients, "TestString", "Test message"); server.WaitForCompletion(); } // Submit the bounce message... CustomAsserts.AssertRecipientsInDeliveryQueue(0); // Download it. message = Pop3ClientSimulator.AssertGetFirstMessageText(account.Address, "test"); Assert.IsTrue(message.Contains("550")); Assert.IsTrue(message.Contains("*****@*****.**")); }
public void TestMultipleHostsTemporaryFailure() { Assert.AreEqual(0, _status.UndeliveredMessages.Length); // No valid recipients... var deliveryResults = new Dictionary<string, int>(); deliveryResults["*****@*****.**"] = 250; deliveryResults["*****@*****.**"] = 250; deliveryResults["*****@*****.**"] = 499; int smtpServerPort = TestSetup.GetNextFreePort(); using (var server = new SmtpServerSimulator(2, smtpServerPort)) { server.AddRecipientResult(deliveryResults); server.AddRecipientResult(deliveryResults); server.StartListen(); // Add a route so we can connect to localhost. Route route = TestSetup.AddRoutePointingAtLocalhostMultipleHosts(2, smtpServerPort); // Send message to this route. var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); recipients.Add("*****@*****.**"); recipients.Add("*****@*****.**"); recipients.Add("*****@*****.**"); smtp.Send("*****@*****.**", recipients, "Test", "Test message"); // Wait for the client to disconnect. server.WaitForCompletion(); } CustomAsserts.AssertRecipientsInDeliveryQueue(1); // Check so that only user 3 remains in the queue. Assert.AreEqual(-1, _status.UndeliveredMessages.IndexOf("*****@*****.**")); Assert.AreEqual(-1, _status.UndeliveredMessages.IndexOf("*****@*****.**")); Assert.AreNotEqual(-1, _status.UndeliveredMessages.IndexOf("*****@*****.**")); using (var server = new SmtpServerSimulator(2, smtpServerPort)) { server.AddRecipientResult(deliveryResults); server.AddRecipientResult(deliveryResults); server.StartListen(); CustomAsserts.AssertRecipientsInDeliveryQueue(0, true); server.WaitForCompletion(); string bounceMessage = Pop3ClientSimulator.AssertGetFirstMessageText("*****@*****.**", "test"); Assert.IsFalse(bounceMessage.Contains("*****@*****.**")); Assert.IsFalse(bounceMessage.Contains("*****@*****.**")); Assert.IsTrue(bounceMessage.Contains("*****@*****.**")); Assert.IsTrue(bounceMessage.Contains("499 [email protected]")); Assert.IsTrue(bounceMessage.Contains("Tried 2 time(s)")); } }
public void SmtpServerSupportingStartTls_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 smtpServer = new SmtpServerSimulator(1, smtpServerPort, eConnectionSecurity.eCSSTARTTLSRequired)) { smtpServer.SetCertificate(SslSetup.GetCertificate()); smtpServer.AddRecipientResult(deliveryResults); smtpServer.StartListen(); Route route = TestSetup.AddRoutePointingAtLocalhost(1, smtpServerPort, true, eConnectionSecurity.eCSSTARTTLSRequired); var smtpClient = new SmtpClientSimulator(); smtpClient.Send(account.Address, "*****@*****.**", "Test", "Test message"); CustomAsserts.AssertRecipientsInDeliveryQueue(0); smtpServer.WaitForCompletion(); Assert.IsTrue(smtpServer.MessageData.Contains("Test message"), smtpServer.MessageData); } }
public void TestMultipleHostsTemporaryFailureDeliveryOnSecondServer() { Assert.AreEqual(0, _status.UndeliveredMessages.Length); // No valid recipients... var deliveryResults = new Dictionary<string, int>(); deliveryResults["*****@*****.**"] = 250; deliveryResults["*****@*****.**"] = 250; deliveryResults["*****@*****.**"] = 450; var deliveryResultsSecond = new Dictionary<string, int>(); deliveryResultsSecond["*****@*****.**"] = 250; deliveryResultsSecond["*****@*****.**"] = 250; deliveryResultsSecond["*****@*****.**"] = 250; int smtpServerPort = TestSetup.GetNextFreePort(); using (var server = new SmtpServerSimulator(2, smtpServerPort)) { server.AddRecipientResult(deliveryResults); server.AddRecipientResult(deliveryResultsSecond); server.StartListen(); // Add a route so we can connect to localhost. TestSetup.AddRoutePointingAtLocalhostMultipleHosts(2, smtpServerPort); // Send message to this route. var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); recipients.Add("*****@*****.**"); recipients.Add("*****@*****.**"); recipients.Add("*****@*****.**"); smtp.Send("*****@*****.**", recipients, "Test", "Accepted message"); // Wait for the client to disconnect. server.WaitForCompletion(); // Trigger a sending of the bounce message. CustomAsserts.AssertRecipientsInDeliveryQueue(0); Assert.IsTrue(server.MessageData.Contains("Accepted message")); } }
private string SendMessage(string body) { SingletonProvider<TestSetup>.Instance.AddAccount(_domain, "*****@*****.**", "test"); var deliveryResults = new Dictionary<string, int>(); deliveryResults["*****@*****.**"] = 250; int port = TestSetup.GetNextFreePort(); using (var server = new SmtpServerSimulator(1, port)) { server.SecondsToWaitBeforeTerminate = 60; server.AddRecipientResult(deliveryResults); server.StartListen(); // Add a route so we can connect to localhost. AddRoutePointingAtLocalhost(5, port); // Send message to this route. var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); recipients.Add("*****@*****.**"); smtp.Send("*****@*****.**", recipients, "Test", body); // Wait for the client to disconnect. server.WaitForCompletion(); string messageData = server.MessageData; CustomAsserts.AssertRecipientsInDeliveryQueue(0); return messageData; } }
public void TestPartialTemporaryErrorFailure() { Assert.AreEqual(0, _status.UndeliveredMessages.Length); // No valid recipients... var deliveryResults = new Dictionary<string, int>(); deliveryResults["*****@*****.**"] = 250; deliveryResults["*****@*****.**"] = 250; deliveryResults["*****@*****.**"] = 400; int smtpServerPort = TestSetup.GetNextFreePort(); using (var server = new SmtpServerSimulator(1, smtpServerPort)) { server.AddRecipientResult(deliveryResults); server.StartListen(); // Add a route so we can connect to localhost. TestSetup.AddRoutePointingAtLocalhost(2, smtpServerPort, false); // Send message to this route. var smtp = new SmtpClientSimulator(); var recipients = new List<string>(); recipients.Add("*****@*****.**"); recipients.Add("*****@*****.**"); recipients.Add("*****@*****.**"); smtp.Send("*****@*****.**", recipients, "Test", "Test message"); // Wait for the client to disconnect. server.WaitForCompletion(); // Trigger a sending of the bounce message. CustomAsserts.AssertRecipientsInDeliveryQueue(1); Assert.AreEqual(-1, _status.UndeliveredMessages.IndexOf("*****@*****.**")); Assert.AreEqual(-1, _status.UndeliveredMessages.IndexOf("*****@*****.**")); Assert.AreNotEqual(-1, _status.UndeliveredMessages.IndexOf("*****@*****.**")); Assert.IsTrue(server.MessageData.Contains("Test message")); } // Attempt to deliver the message again. using (var server = new SmtpServerSimulator(1, smtpServerPort)) { server.AddRecipientResult(deliveryResults); server.StartListen(); TestSetup.SendMessagesInQueue(); server.WaitForCompletion(); // CustomAsserts.AssertRecipientsInDeliveryQueue(0); string bounceMessage = Pop3ClientSimulator.AssertGetFirstMessageText("*****@*****.**", "test"); Assert.IsTrue(bounceMessage.Contains("400 [email protected]")); Assert.IsTrue(bounceMessage.Contains("Tried 2 time(s)")); Assert.IsFalse(bounceMessage.Contains("*****@*****.**")); Assert.IsFalse(bounceMessage.Contains("*****@*****.**")); } }
public void ShouldBePossibleToSendToRouteWithTargetIPAddress() { // 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)) { server.AddRecipientResult(deliveryResults); server.StartListen(); Route route = TestSetup.AddRoutePointingAtLocalhost(1, smtpServerPort, true, eConnectionSecurity.eCSNone); route.TargetSMTPHost = "127.0.0.1"; route.Save(); var smtpSimulator = new SmtpClientSimulator(); smtpSimulator.Send("*****@*****.**", "*****@*****.**", "Mail 1", "Test message"); // This should now be processed via the rule -> route -> external server we've set up. server.WaitForCompletion(); var log = LogHandler.ReadCurrentDefaultLog(); Assert.IsTrue(server.MessageData.Contains("Test message")); } }
public void TestPermanentFailure() { Assert.AreEqual(0, _status.UndeliveredMessages.Length); var deliveryResults = new Dictionary<string, int>(); deliveryResults["*****@*****.**"] = 542; int smtpServerPort = TestSetup.GetNextFreePort(); using (var server = new SmtpServerSimulator(1, smtpServerPort)) { server.AddRecipientResult(deliveryResults); server.StartListen(); // Add a route so we can connect to localhost. TestSetup.AddRoutePointingAtLocalhost(5, smtpServerPort, false); // 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(); Assert.IsFalse(server.Conversation.Contains("\r\nDATA\r\n")); } CustomAsserts.AssertRecipientsInDeliveryQueue(0); string bounce = Pop3ClientSimulator.AssertGetFirstMessageText(_account.Address, "test"); Assert.IsTrue(bounce.Contains("Remote server replied: 542 [email protected]")); }
public void RoutesShouldHaveHigherPrioThanSMTPRelay() { // Set up a server listening on port 250 which accepts email for [email protected] var deliveryResults = new Dictionary<string, int>(); deliveryResults["*****@*****.**"] = 250; // We set the SMTP relayer here, but this should be ignored since the recipient's // address matches a route set up (test.com). _application.Settings.SMTPRelayer = "example.com"; 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 = false; route.Save(); // Make sure only the specific user is valid. RouteAddress routeAddress = route.Addresses.Add(); routeAddress.Address = "user@" + _domain.Name; routeAddress.Save(); SingletonProvider<TestSetup>.Instance.AddAlias(_domain, "*****@*****.**", "*****@*****.**"); var smtpClient = new SmtpClientSimulator(); smtpClient.Send("*****@*****.**", "*****@*****.**", "Test", "Test message"); CustomAsserts.AssertRecipientsInDeliveryQueue(0); server.WaitForCompletion(); Assert.IsTrue(server.MessageData.Contains("Test message")); } }
public void TestSMTPClientTimeout() { 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.Sleep15MinutesAfterSessionStart; server.SecondsToWaitBeforeTerminate = 20*60; 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); }