class MailSenderTest(unittest.TestCase):
def setUp(self):
self._cert_path = u'/some/cert/path'
self._keymanager_mock = mock()
self._remote_smtp_host = 'some.host.test'
self._remote_smtp_port = 1234
self._smtp_config = LeapSMTPConfig('*****@*****.**', self._cert_path, self._remote_smtp_host, self._remote_smtp_port)
self.sender = MailSender(self._smtp_config, self._keymanager_mock)
def tearDown(self):
unstub()
@defer.inlineCallbacks
def test_iterates_over_recipients(self):
input_mail = InputMail.from_dict(mail_dict(), from_address='pixelated@org')
when(OutgoingMail).send_message(any(), any()).thenReturn(defer.succeed(None))
yield self.sender.sendmail(input_mail)
for recipient in flatten([input_mail.to, input_mail.cc, input_mail.bcc]):
verify(OutgoingMail).send_message(any(), TwistedSmtpUserCapture(recipient))
@defer.inlineCallbacks
def test_send_leaves_mail_in_tact(self):
input_mail_dict = mail_dict()
input_mail = InputMail.from_dict(input_mail_dict, from_address='pixelated@org')
when(OutgoingMail).send_message(any(), any()).thenReturn(defer.succeed(None))
yield self.sender.sendmail(input_mail)
self.assertEqual(input_mail.to, input_mail_dict["header"]["to"])
self.assertEqual(input_mail.cc, input_mail_dict["header"]["cc"])
self.assertEqual(input_mail.bcc, input_mail_dict["header"]["bcc"])
self.assertEqual(input_mail.subject, input_mail_dict["header"]["subject"])
@defer.inlineCallbacks
def test_problem_with_email_raises_exception(self):
input_mail = InputMail.from_dict(mail_dict(), from_address='pixelated@org')
when(OutgoingMail).send_message(any(), any()).thenReturn(defer.fail(Exception('pretend something went wrong')))
try:
yield self.sender.sendmail(input_mail)
self.fail('Exception expected!')
except MailSenderException, e:
for recipient in flatten([input_mail.to, input_mail.cc, input_mail.bcc]):
self.assertTrue(recipient in e.email_error_map)
def test_sendmail(self):
when(reactor).connectTCP('localhost', 4650, any()).thenReturn(None)
input_mail = InputMail.from_dict(mail_dict())
mail_sender = MailSender('*****@*****.**',
self.ensure_smtp_is_running_cb)
return self._succeed(mail_sender.sendmail(input_mail))
class MailSenderTest(unittest.TestCase):
def setUp(self):
self._cert_path = u'/some/cert/path'
self._keymanager_mock = mock()
self._remote_smtp_host = 'some.host.test'
self._remote_smtp_port = 1234
self._smtp_config = LeapSMTPConfig('*****@*****.**',
self._cert_path,
self._remote_smtp_host,
self._remote_smtp_port)
self.sender = MailSender(self._smtp_config, self._keymanager_mock)
def tearDown(self):
unstub()
@defer.inlineCallbacks
def test_iterates_over_recipients(self):
input_mail = InputMail.from_dict(mail_dict(),
from_address='pixelated@org')
when(OutgoingMail).send_message(any(),
any()).thenReturn(defer.succeed(None))
yield self.sender.sendmail(input_mail)
for recipient in flatten(
[input_mail.to, input_mail.cc, input_mail.bcc]):
verify(OutgoingMail).send_message(
any(), TwistedSmtpUserCapture(recipient))
@defer.inlineCallbacks
def test_problem_with_email_raises_exception(self):
input_mail = InputMail.from_dict(mail_dict(),
from_address='pixelated@org')
when(OutgoingMail).send_message(any(), any()).thenReturn(
defer.fail(Exception('pretend something went wrong')))
try:
yield self.sender.sendmail(input_mail)
self.fail('Exception expected!')
except MailSenderException, e:
for recipient in flatten(
[input_mail.to, input_mail.cc, input_mail.bcc]):
self.assertTrue(recipient in e.email_error_map)
def test_iterates_over_recipients(self):
sender = MailSender(self._smtp_config, self._keymanager_mock)
input_mail = InputMail.from_dict(mail_dict())
when(OutgoingMail).send_message(any(), any()).thenAnswer(lambda: defer.succeed(None))
yield sender.sendmail(input_mail)
for recipient in flatten([input_mail.to, input_mail.cc, input_mail.bcc]):
verify(OutgoingMail).send_message(any(), TwistedSmtpUserCapture(recipient))
def test_senmail_returns_deffered(self):
when(reactor).connectTCP('localhost', 4650, any()).thenReturn(None)
input_mail = InputMail.from_dict(mail_dict())
mail_sender = MailSender('*****@*****.**', self.smtp)
deferred = mail_sender.sendmail(input_mail)
self.assertIsNotNone(deferred)
self.assertTrue(isinstance(deferred, Deferred))
return self._succeed(deferred)
def test_doesnt_send_mail_if_smtp_is_not_running(self):
mail_sender = MailSender('*****@*****.**', self.ensure_smtp_is_not_running_cb)
deferred = mail_sender.sendmail({})
def _assert(_):
self.assertTrue(isinstance(deferred.result.value, SMTPDownException))
deferred.addErrback(_assert)
return deferred
def test_senmail_returns_deffered(self):
when(reactor).connectTCP('localhost', 4650, any()).thenReturn(None)
input_mail = InputMail.from_dict(mail_dict())
mail_sender = MailSender('*****@*****.**', self.smtp)
deferred = mail_sender.sendmail(input_mail)
self.assertIsNotNone(deferred)
self.assertTrue(isinstance(deferred, Deferred))
return self._succeed(deferred)
def test_sendmail_uses_twisted(self):
when(reactor).connectTCP('localhost', 4650, any()).thenReturn(None)
input_mail = InputMail.from_dict(mail_dict())
mail_sender = MailSender('*****@*****.**', self.smtp)
sent_deferred = mail_sender.sendmail(input_mail)
verify(reactor).connectTCP('localhost', 4650, any())
return self._succeed(sent_deferred)
def test_problem_with_email_raises_exception(self):
sender = MailSender(self._smtp_config, self._keymanager_mock)
input_mail = InputMail.from_dict(mail_dict())
when(OutgoingMail).send_message(any(), any()).thenAnswer(lambda: defer.fail(Exception('pretend something went wrong')))
try:
yield sender.sendmail(input_mail)
self.fail('Exception expected!')
except MailSenderException, e:
for recipient in flatten([input_mail.to, input_mail.cc, input_mail.bcc]):
self.assertTrue(recipient in e.email_error_map)
def test_sendmail_uses_twisted(self):
when(reactor).connectTCP('localhost', 4650, any()).thenReturn(None)
input_mail = InputMail.from_dict(mail_dict())
mail_sender = MailSender('*****@*****.**', self.smtp)
sent_deferred = mail_sender.sendmail(input_mail)
verify(reactor).connectTCP('localhost', 4650, any())
return self._succeed(sent_deferred)
def test_doesnt_send_mail_if_smtp_is_not_running(self):
mail_sender = MailSender('*****@*****.**',
self.ensure_smtp_is_not_running_cb)
deferred = mail_sender.sendmail({})
def _assert(_):
self.assertTrue(
isinstance(deferred.result.value, SMTPDownException))
deferred.addErrback(_assert)
return deferred
def test_iterates_over_recipients(self):
sender = MailSender(self._smtp_config, self._keymanager_mock)
input_mail = InputMail.from_dict(mail_dict())
when(OutgoingMail).send_message(
any(), any()).thenAnswer(lambda: defer.succeed(None))
yield sender.sendmail(input_mail)
for recipient in flatten(
[input_mail.to, input_mail.cc, input_mail.bcc]):
verify(OutgoingMail).send_message(
any(), TwistedSmtpUserCapture(recipient))
def test_problem_with_email_raises_exception(self):
sender = MailSender(self._smtp_config, self._keymanager_mock)
input_mail = InputMail.from_dict(mail_dict())
when(OutgoingMail).send_message(any(), any()).thenAnswer(
lambda: defer.fail(Exception('pretend something went wrong')))
try:
yield sender.sendmail(input_mail)
self.fail('Exception expected!')
except MailSenderException, e:
for recipient in flatten(
[input_mail.to, input_mail.cc, input_mail.bcc]):
self.assertTrue(recipient in e.email_error_map)
def test_sendmail(self):
when(reactor).connectTCP('localhost', 4650, any()).thenReturn(None)
input_mail = InputMail.from_dict(mail_dict())
mail_sender = MailSender('*****@*****.**', self.ensure_smtp_is_running_cb)
return self._succeed(mail_sender.sendmail(input_mail))
