class ParsingMailsWithAttachments(TestCase):
def setUp(self):
super(ParsingMailsWithAttachments, self).setUp()
self.outbound_message = OutboundMessage.objects.get(id=1)
self.outbound_message.outboundmessageidentifier.key = '4aaaabbb'
self.outbound_message.outboundmessageidentifier.save()
self.mail_with_attachments = ""
with open('mailit/tests/fixture/mail_with_attachments.txt') as f:
self.mail_with_attachments += f.read()
f.close()
self.handler = EmailHandler(answer_class=OutboundMessageAnswer)
def test_handle_mail_with_attachments(self):
'''Handle mails with attachments creates some'''
email_answer = self.handler.handle(self.mail_with_attachments)
answer = email_answer.send_back()
self.assertTrue(email_answer.attachments)
self.assertTrue(answer.attachments.all())
def test_attachments_with_names(self):
'''When I get an attachment it should have names'''
email_answer = self.handler.handle(self.mail_with_attachments)
answer = email_answer.send_back()
self.assertTrue(answer.attachments.filter(name="fiera_parque.jpg"))
self.assertTrue(answer.attachments.filter(name="hello.pd.pdf"))
self.assertTrue(answer.attachments.filter(name="hello.docx"))
class HandleBounces(TestCase):
def setUp(self):
super(HandleBounces, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/bounced_mail2.txt')
self.email = f.readlines()
f.close()
self.where_to_post_a_bounce = 'http://writeit.ciudadanointeligente.org//api/v1/handle_bounce/'
config.WRITEIT_API_WHERE_TO_REPORT_A_BOUNCE = self.where_to_post_a_bounce
config.WRITEIT_API_KEY = self.user.api_key.key
config.WRITEIT_USERNAME = self.user.username
self.handler = EmailHandler()
def test_after_handling_the_message_is_set_to_bounced(self):
self.answer = self.handler.handle(self.email)
self.assertTrue(self.answer.is_bounced)
def test_it_handles_the_bounces_and_pushes_the_identifier_key_to_the_api(self):
self.answer = self.handler.handle(self.email)
self.assertEquals(self.answer.requests_session.auth.api_key, self.user.api_key.key)
self.assertEquals(self.answer.requests_session.auth.username, self.user.username)
expected_headers = {'content-type': 'application/json'}
data = {'key': self.answer.outbound_message_identifier}
data = json.dumps(data)
with patch('requests.Session.post') as post:
post.return_value = PostMock()
self.answer.report_bounce()
post.assert_called_with(self.where_to_post_a_bounce, data=data, headers=expected_headers)
def handle(self, *args, **options):
lines = sys.stdin.readlines()
if settings.INCOMING_EMAIL_LOGGING == 'ALL':
if not settings.ADMINS:
return
text_content = "New incomming email"
subject = "New incomming email"
mail = EmailMultiAlternatives('%s%s' % (settings.EMAIL_SUBJECT_PREFIX, subject),
text_content, # content
settings.DEFAULT_FROM_EMAIL, # From
[a[1] for a in settings.ADMINS] # To
)
mail.attach('mail.txt', ''.join(lines), 'text/plain')
mail.send()
handler = EmailHandler(answer_class=AnswerForManageCommand)
try:
answer = handler.handle(lines)
answer.send_back()
except CouldNotFindIdentifier:
pass
except:
tb = traceback.format_exc()
text_content = "Error the traceback was:\n" + tb
#mail_admins('Error handling incoming email', html_message, html_message=html_message)
subject = "Error handling incoming email"
mail = EmailMultiAlternatives('%s%s' % (settings.EMAIL_SUBJECT_PREFIX, subject),
text_content, # content
settings.DEFAULT_FROM_EMAIL, # From
[a[1] for a in settings.ADMINS], # To
)
mail.attach('mail.txt', ''.join(lines), 'text/plain')
mail.send()
def setUp(self):
super(ResendOutboundMessages, self).setUp()
self.contact = Contact.objects.get(
value="*****@*****.**")
self.contact.is_bounced = True
self.contact.save()
self.outbound_messages = OutboundMessage.objects.filter(
contact=self.contact)
for outbound_message in self.outbound_messages:
outbound_message.send()
outbound_message.status = "error"
outbound_message.save()
identifier = OutboundMessageIdentifier.objects.get(
outbound_message=outbound_message)
identifier.key = "4aaaabbb"
#This might fail if there are more than one outbound message!!!
identifier.save()
#This might fail if there are more than one outbound message!!
#please fix if necesary by only choosing the first one or by using a try - except
self.previous_amount_of_mails = len(mail.outbox)
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail.txt') as f:
self.bounced_email += f.read()
f.close()
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
self.answer = self.handler.handle(self.bounced_email)
self.answer.send_back()
def post(self, request):
handler = EmailHandler(answer_class=OutboundMessageAnswer)
email = request.POST['email']
try:
logger.debug("SendGrid Inbound mail webhook POST email\n\n%s" %
email)
answer = handler.handle(email)
answer.send_back()
except CouldNotFindIdentifier as e:
logger.warn(e)
except Exception as e:
tb = traceback.format_exc()
text_content = "Error the traceback was:\n" + tb
#mail_admins('Error handling incoming email', html_message, html_message=html_message)
subject = "Error handling incoming email"
mail = EmailMultiAlternatives(
'%s%s' % (settings.EMAIL_SUBJECT_PREFIX, subject),
text_content, # content
settings.DEFAULT_FROM_EMAIL, # From
[a[1] for a in settings.ADMINS], # To
)
mail.attach('mail.txt', email, 'text/plain')
mail.send()
raise e
return HttpResponse()
class ParsingMailsWithAttachments(TestCase):
def setUp(self):
super(ParsingMailsWithAttachments, self).setUp()
self.outbound_message = OutboundMessage.objects.get(id=1)
self.outbound_message.outboundmessageidentifier.key = '4aaaabbb'
self.outbound_message.outboundmessageidentifier.save()
self.mail_with_attachments = ""
with open('mailit/tests/fixture/mail_with_attachments.txt') as f:
self.mail_with_attachments += f.read()
f.close()
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
def test_handle_mail_with_attachments(self):
'''Handle mails with attachments creates some'''
email_answer = self.handler.handle(self.mail_with_attachments)
answer = email_answer.send_back()
self.assertTrue(email_answer.attachments)
self.assertTrue(answer.attachments.all())
def test_attachments_with_names(self):
'''When I get an attachment it should have names'''
email_answer = self.handler.handle(self.mail_with_attachments)
answer = email_answer.send_back()
self.assertTrue(answer.attachments.filter(name="fiera_parque.jpg"))
self.assertTrue(answer.attachments.filter(name="hello.pd.pdf"))
self.assertTrue(answer.attachments.filter(name="hello.docx"))
def setUp(self):
super(ParsingMailsWithAttachments, self).setUp()
self.outbound_message = OutboundMessage.objects.get(id=1)
self.outbound_message.outboundmessageidentifier.key = '4aaaabbb'
self.outbound_message.outboundmessageidentifier.save()
self.mail_with_attachments = ""
with open('mailit/tests/fixture/mail_with_attachments.txt') as f:
self.mail_with_attachments += f.read()
f.close()
self.handler = EmailHandler(answer_class=OutboundMessageAnswer)
def setUp(self):
super(HandleBounces, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/bounced_mail2.txt')
self.email = f.readlines()
f.close()
self.where_to_post_a_bounce = 'http://writeit.ciudadanointeligente.org//api/v1/handle_bounce/'
config.WRITEIT_API_WHERE_TO_REPORT_A_BOUNCE = self.where_to_post_a_bounce
config.WRITEIT_API_KEY = self.user.api_key.key
config.WRITEIT_USERNAME = self.user.username
self.handler = EmailHandler()
def setUp(self):
super(ReplyHandlerTestCase, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/reply_mail.txt')
self.email = f.readlines()
f.close()
self.where_to_post_creation_of_the_answer = 'http://localhost:8000/api/v1/create_answer/'
config.WRITEIT_API_ANSWER_CREATION = self.where_to_post_creation_of_the_answer
config.WRITEIT_API_KEY = self.user.api_key.key
config.WRITEIT_USERNAME = self.user.username
self.handler = EmailHandler()
class EmailReadingExamplesTestCase(TestCase):
def setUp(self):
super(EmailReadingExamplesTestCase, self).setUp()
self.message = Message.objects.get(id=1)
self.contact = Contact.objects.get(value="*****@*****.**")
self.outbound_message = OutboundMessage.objects.create(message=self.message, contact=self.contact)
self.outbound_message.send()
identifier = OutboundMessageIdentifier.objects.get(outbound_message=self.outbound_message)
identifier.key = "7e460e9c462411e38ef81231400178dd"
identifier.save()
self.handler = EmailHandler()
def test_example1_gmail(self):
f = open('mailit/tests/fixture/example1_gmail.txt')
email = f.readlines()
f.close()
answer = self.handler.handle(email)
self.assertEquals(answer.content_text, u"si prueba no más")
self.assertIn(u"si prueba no más", answer.content_html)
@skip("this fails because it still has some parts from the origina email, probably this is not easy taken away")
def test_example2_gmail(self):
f = open('mailit/tests/fixture/example2_gmail.txt')
email = f.readlines()
f.close()
answer = self.handler.handle(email)
self.assertEquals(answer.content_text, u"de nuevo de nuevo")
def test_example3_ipad(self):
f = open('mailit/tests/fixture/example3_ipad.txt')
email = f.readlines()
f.close()
answer = self.handler.handle(email)
self.assertEquals(answer.content_text, u"Primero que todo los felicito por la iniciativa , ojalá lleguen más preguntas .")
def test_example4_hotmail(self):
f = open('mailit/tests/fixture/example4_hotmail.txt')
email = f.readlines()
f.close()
answer = self.handler.handle(email)
self.assertIn(u"chilen@ está ausente más de 10 horas de su hogar despreocup", answer.content_text)
def test_example5_michellebachelet(self):
f = open('mailit/tests/fixture/example5_michellebachelet.txt')
email = f.readlines()
f.close()
answer = self.handler.handle(email)
self.assertIn(u"Realizaremos un proceso de consulta con los Pueblos", answer.content_text)
def setUp(self):
super(DoesNotIncludeTheIdentifierInTheContent, self).setUp()
self.user = User.objects.get(id=1)
f = open(
'mailit/tests/fixture/mail_with_identifier_in_the_content.txt')
self.email = f.readlines()
f.close()
self.where_to_post_creation_of_the_answer = 'http://localhost:8000/api/v1/create_answer/'
config.WRITEIT_API_ANSWER_CREATION = self.where_to_post_creation_of_the_answer
config.WRITEIT_API_KEY = self.user.api_key.key
config.WRITEIT_USERNAME = self.user.username
self.handler = EmailHandler()
def setUp(self):
super(BouncedMessageRecordTestCase, self).setUp()
self.outbound_message = OutboundMessage.objects.get(id=1)
self.identifier = OutboundMessageIdentifier.objects.first()
self.identifier.key = '4aaaabbb'
self.identifier.save()
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail2.txt') as f:
self.bounced_email += f.read()
f.close()
self.bounced_email.replace(self.identifier.key, '')
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
def setUp(self):
super(EmailReadingExamplesTestCase, self).setUp()
self.message = Message.objects.get(id=1)
self.contact = Contact.objects.get(
value="*****@*****.**")
self.outbound_message = OutboundMessage.objects.create(
message=self.message,
contact=self.contact,
site=Site.objects.get_current())
self.outbound_message.send()
identifier = OutboundMessageIdentifier.objects.get(
outbound_message=self.outbound_message)
identifier.key = "7e460e9c462411e38ef81231400178dd"
identifier.save()
self.handler = EmailHandler()
class DoesNotIncludeTheIdentifierInTheContent(TestCase):
def setUp(self):
super(DoesNotIncludeTheIdentifierInTheContent, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/mail_with_identifier_in_the_content.txt')
self.email = f.readlines()
f.close()
self.where_to_post_creation_of_the_answer = 'http://*****:*****@mailit.ciudadanointeligente.org", self.answer.content_text)
with patch('requests.Session.post') as post:
post.return_value = PostMock()
self.answer.send_back()
post.assert_called_with(self.where_to_post_creation_of_the_answer, data=data, headers=expected_headers)
class FlaggingBouncedMailWriteItDefault(TestCase):
def setUp(self):
super(FlaggingBouncedMailWriteItDefault, self).setUp()
self.message = Message.objects.get(id=1)
self.contact = Contact.objects.get(
value="*****@*****.**")
self.outbound_message = OutboundMessage.objects.create(
message=self.message,
contact=self.contact,
site=Site.objects.get_current())
identifier = OutboundMessageIdentifier.objects.get(
outbound_message=self.outbound_message)
identifier.key = "4aaaabbb"
identifier.save()
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail2.txt') as f:
self.bounced_email += f.read()
f.close()
self.handler = EmailHandler(answer_class=OutboundMessageAnswer)
self.answer = self.handler.handle(self.bounced_email)
self.answer.send_back()
def test_it_marks_the_contact_as_bounced_when_flag_bounced_contact_is_true(
self):
contact = Contact.objects.get(
value="*****@*****.**")
self.assertTrue(contact.is_bounced)
def setUp(self):
super(ResendOutboundMessages, self).setUp()
self.contact = Contact.objects.get(value="*****@*****.**")
self.contact.is_bounced = True
self.contact.save()
self.outbound_messages = OutboundMessage.objects.filter(contact=self.contact)
for outbound_message in self.outbound_messages:
outbound_message.send()
outbound_message.status = "error"
outbound_message.save()
identifier = OutboundMessageIdentifier.objects.get(outbound_message=outbound_message)
identifier.key = "4aaaabbb"
#This might fail if there are more than one outbound message!!!
identifier.save()
#This might fail if there are more than one outbound message!!
#please fix if necesary by only choosing the first one or by using a try - except
self.previous_amount_of_mails = len(mail.outbox)
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail.txt') as f:
self.bounced_email += f.read()
f.close()
self.handler = EmailHandler(answer_class = AnswerForManageCommand)
self.answer = self.handler.handle(self.bounced_email)
self.answer.send_back()
class BouncedMailInAmazonBug(TestCase):
def setUp(self):
super(BouncedMailInAmazonBug, self).setUp()
self.message = Message.objects.get(id=1)
self.contact = Contact.objects.get(
value="*****@*****.**")
self.outbound_message = OutboundMessage.objects.create(
message=self.message,
contact=self.contact,
site=Site.objects.get_current())
identifier = OutboundMessageIdentifier.objects.get(
outbound_message=self.outbound_message)
identifier.key = "4aaaabbb"
identifier.save()
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail2.txt') as f:
self.bounced_email += f.read()
f.close()
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
self.answer = self.handler.handle(self.bounced_email)
self.answer.send_back()
def test_it_marks_the_contact_as_a_bounce(self):
contact = Contact.objects.get(
value="*****@*****.**")
self.assertTrue(contact.is_bounced)
def test_it_marks_the_outbound_message_as_an_error(self):
#I have to look for it again cause it has changed in the DB
outbound_message = OutboundMessage.objects.get(
id=self.outbound_message.id)
self.assertEquals(outbound_message.status, "error")
class BouncedMessageRecordTestCase(TestCase):
def setUp(self):
super(BouncedMessageRecordTestCase, self).setUp()
self.outbound_message = OutboundMessage.objects.get(id=1)
self.identifier = OutboundMessageIdentifier.objects.first()
self.identifier.key = '4aaaabbb'
self.identifier.save()
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail2.txt') as f:
self.bounced_email += f.read()
f.close()
self.bounced_email.replace(self.identifier.key, '')
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
def test_creation(self):
bounced_message = BouncedMessageRecord.objects.create(
outbound_message=self.outbound_message,
bounce_text=self.bounced_email,
)
self.assertTrue(bounced_message)
self.assertEquals(bounced_message.outbound_message, self.outbound_message)
self.assertFalse(bounced_message.date is None)
self.assertEquals(bounced_message.bounce_text, self.bounced_email)
def test_it_creates_a_bounced_message_when_comes_a_new_bounce(self):
email_answer = self.handler.handle(self.bounced_email)
identifier = OutboundMessageIdentifier.objects.get(key=email_answer.outbound_message_identifier)
outbound_message = OutboundMessage.objects.get(outboundmessageidentifier=identifier)
email_answer.send_back()
bounced_messages = BouncedMessageRecord.objects.filter(outbound_message=outbound_message)
self.assertEquals(bounced_messages.count(), 1)
bounced_message = bounced_messages[0]
self.assertEquals(bounced_message.bounce_text, email_answer.content_text)
class BouncedMailInGmail(TestCase):
def setUp(self):
super(BouncedMailInGmail, self).setUp()
self.message = Message.objects.get(id=1)
self.contact = Contact.objects.get(value="*****@*****.**")
self.outbound_message = OutboundMessage.objects.create(
message=self.message, contact=self.contact)
self.outbound_message.send()
identifier = OutboundMessageIdentifier.objects.get(outbound_message=self.outbound_message)
identifier.key = "4aaaabbb"
identifier.save()
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail.txt') as f:
self.bounced_email += f.read()
f.close()
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
self.answer = self.handler.handle(self.bounced_email)
self.answer.send_back()
def test_it_marks_the_contact_as_a_bounce(self):
contact = Contact.objects.get(value="*****@*****.**")
self.assertTrue(contact.is_bounced)
def test_it_marks_the_outbound_message_as_an_error(self):
#I have to look for it again cause it has changed in the DB
outbound_message = OutboundMessage.objects.get(id=self.outbound_message.id)
self.assertEquals(outbound_message.status, "error")
def test_it_marks_the_outbound_record_to_try_again(self):
record = OutboundMessagePluginRecord.objects.get(outbound_message=self.outbound_message)
self.assertTrue(record.try_again)
def setUp(self):
super(ParsingMailsWithAttachments, self).setUp()
self.outbound_message = OutboundMessage.objects.get(id=1)
self.outbound_message.outboundmessageidentifier.key = '4aaaabbb'
self.outbound_message.outboundmessageidentifier.save()
self.mail_with_attachments = ""
with open('mailit/tests/fixture/mail_with_attachments.txt') as f:
self.mail_with_attachments += f.read()
f.close()
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
def setUp(self):
super(EmailReadingExamplesTestCase, self).setUp()
self.message = Message.objects.get(id=1)
self.contact = Contact.objects.get(value="*****@*****.**")
self.outbound_message = OutboundMessage.objects.create(message=self.message, contact=self.contact)
self.outbound_message.send()
identifier = OutboundMessageIdentifier.objects.get(outbound_message=self.outbound_message)
identifier.key = "7e460e9c462411e38ef81231400178dd"
identifier.save()
self.handler = EmailHandler()
class ResendOutboundMessages(TestCase):
def setUp(self):
super(ResendOutboundMessages, self).setUp()
self.contact = Contact.objects.get(value="*****@*****.**")
self.contact.is_bounced = True
self.contact.save()
self.outbound_messages = OutboundMessage.objects.filter(contact=self.contact)
for outbound_message in self.outbound_messages:
outbound_message.send()
outbound_message.status = "error"
outbound_message.save()
identifier = OutboundMessageIdentifier.objects.get(outbound_message=outbound_message)
identifier.key = "4aaaabbb"
#This might fail if there are more than one outbound message!!!
identifier.save()
#This might fail if there are more than one outbound message!!
#please fix if necesary by only choosing the first one or by using a try - except
self.previous_amount_of_mails = len(mail.outbox)
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail.txt') as f:
self.bounced_email += f.read()
f.close()
self.handler = EmailHandler(answer_class = AnswerForManageCommand)
self.answer = self.handler.handle(self.bounced_email)
self.answer.send_back()
def test_resend_outbound_messages(self):
self.contact.resend_messages()
outbound_messages = OutboundMessage.objects.filter(contact=self.contact)
current_amount_of_mails_sent_after_resend_messages = len(mail.outbox)
self.assertEquals(current_amount_of_mails_sent_after_resend_messages - self.previous_amount_of_mails, outbound_messages.count())
for outbound_message in outbound_messages:
self.assertEquals(outbound_message.status,"sent")
def test_resends_only_failed_outbound_messages(self):
message = Message.objects.all()[0]
non_failed_outbound_message = OutboundMessage.objects.create(message=message, contact=self.contact, status="ready")
self.contact.resend_messages()
current_amount_of_mails_sent_after_resend_messages = len(mail.outbox)
self.assertEquals(current_amount_of_mails_sent_after_resend_messages - self.previous_amount_of_mails,
self.outbound_messages.count())
def test_it_sets_the_is_bounced_status_to_false_of_the_contact(self):
self.contact.resend_messages()
contact = Contact.objects.get(id=self.contact.id)
self.assertFalse(contact.is_bounced)
def setUp(self):
super(HandleBounces, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/bounced_mail2.txt')
self.email = f.readlines()
f.close()
self.where_to_post_a_bounce = 'http://writeit.ciudadanointeligente.org//api/v1/handle_bounce/'
config.WRITEIT_API_WHERE_TO_REPORT_A_BOUNCE = self.where_to_post_a_bounce
config.WRITEIT_API_KEY = self.user.api_key.key
config.WRITEIT_USERNAME = self.user.username
self.handler = EmailHandler()
def setUp(self):
super(IncomingEmailHandlerTestCase, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/mail.txt')
self.email = f.readlines()
f.close()
self.where_to_post_creation_of_the_answer = 'http://localhost:8000/api/v1/create_answer/'
config.WRITEIT_API_ANSWER_CREATION = self.where_to_post_creation_of_the_answer
config.WRITEIT_API_KEY = self.user.api_key.key
config.WRITEIT_USERNAME = self.user.username
self.handler = EmailHandler()
def post(self, request):
handler = EmailHandler(answer_class=OutboundMessageAnswer)
email = request.POST['email']
try:
logger.debug("SendGrid Inbound mail webhook POST email\n\n%s" % email)
answer = handler.handle(email)
answer.send_back()
except CouldNotFindIdentifier as e:
logger.warn(e)
except OutboundMessageIdentifier.DoesNotExist as e:
logger.exception(e)
tb = traceback.format_exc()
send_error_email(email, tb)
except Exception as e:
tb = traceback.format_exc()
send_error_email(email, tb)
raise e
return HttpResponse()
def setUp(self):
super(DoesNotIncludeTheIdentifierInTheContent, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/mail_with_identifier_in_the_content.txt')
self.email = f.readlines()
f.close()
self.where_to_post_creation_of_the_answer = 'http://localhost:8000/api/v1/create_answer/'
config.WRITEIT_API_ANSWER_CREATION = self.where_to_post_creation_of_the_answer
config.WRITEIT_API_KEY = self.user.api_key.key
config.WRITEIT_USERNAME = self.user.username
self.handler = EmailHandler()
def setUp(self):
super(BouncedMailInAmazonBug, self).setUp()
self.message = Message.objects.get(id=1)
self.contact = Contact.objects.get(
value="*****@*****.**")
self.outbound_message = OutboundMessage.objects.create(
message=self.message,
contact=self.contact,
site=Site.objects.get_current())
identifier = OutboundMessageIdentifier.objects.get(
outbound_message=self.outbound_message)
identifier.key = "4aaaabbb"
identifier.save()
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail2.txt') as f:
self.bounced_email += f.read()
f.close()
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
self.answer = self.handler.handle(self.bounced_email)
self.answer.send_back()
def setUp(self):
super(BouncedMessageRecordTestCase, self).setUp()
self.outbound_message = OutboundMessage.objects.get(id=1)
self.identifier = OutboundMessageIdentifier.objects.first()
self.identifier.key = '4aaaabbb'
self.identifier.save()
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail2.txt') as f:
self.bounced_email += f.read()
f.close()
self.bounced_email.replace(self.identifier.key, '')
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
def handle(self, *args, **options):
lines = sys.stdin.readlines()
if settings.INCOMING_EMAIL_LOGGING == 'ALL':
if not settings.ADMINS:
return
text_content = "New incomming email"
subject = "New incomming email"
mail = EmailMultiAlternatives(
'%s%s' % (settings.EMAIL_SUBJECT_PREFIX, subject),
text_content, # content
settings.DEFAULT_FROM_EMAIL, # From
[a[1] for a in settings.ADMINS] # To
)
mail.attach('mail.txt', ''.join(lines), 'text/plain')
mail.send()
handler = EmailHandler(answer_class=AnswerForManageCommand)
try:
answer = handler.handle(lines)
answer.send_back()
except CouldNotFindIdentifier:
pass
except TemporaryFailure:
pass
except:
tb = traceback.format_exc()
text_content = "Error the traceback was:\n" + tb
#mail_admins('Error handling incoming email', html_message, html_message=html_message)
subject = "Error handling incoming email"
mail = EmailMultiAlternatives(
'%s%s' % (settings.EMAIL_SUBJECT_PREFIX, subject),
text_content, # content
settings.DEFAULT_FROM_EMAIL, # From
[a[1] for a in settings.ADMINS], # To
)
mail.attach('mail.txt', ''.join(lines), 'text/plain')
mail.send()
class HandleBounces(TestCase):
def setUp(self):
super(HandleBounces, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/bounced_mail2.txt')
self.email = f.readlines()
f.close()
self.where_to_post_a_bounce = 'http://writeit.ciudadanointeligente.org//api/v1/handle_bounce/'
config.WRITEIT_API_WHERE_TO_REPORT_A_BOUNCE = self.where_to_post_a_bounce
config.WRITEIT_API_KEY = self.user.api_key.key
config.WRITEIT_USERNAME = self.user.username
self.handler = EmailHandler()
def test_after_handling_the_message_is_set_to_bounced(self):
self.answer = self.handler.handle(self.email)
self.assertTrue(self.answer.is_bounced)
def test_it_handles_the_bounces_and_pushes_the_identifier_key_to_the_api(
self):
self.answer = self.handler.handle(self.email)
self.assertEquals(self.answer.requests_session.auth.api_key,
self.user.api_key.key)
self.assertEquals(self.answer.requests_session.auth.username,
self.user.username)
expected_headers = {'content-type': 'application/json'}
data = {'key': self.answer.outbound_message_identifier}
data = json.dumps(data)
with patch('requests.Session.post') as post:
post.return_value = PostMock()
self.answer.report_bounce()
post.assert_called_with(self.where_to_post_a_bounce,
data=data,
headers=expected_headers)
class ReplyHandlerTestCase(ResourceTestCase):
def setUp(self):
super(ReplyHandlerTestCase, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/reply_mail.txt')
self.email = f.readlines()
f.close()
self.where_to_post_creation_of_the_answer = 'http://localhost:8000/api/v1/create_answer/'
config.WRITEIT_API_ANSWER_CREATION = self.where_to_post_creation_of_the_answer
config.WRITEIT_API_KEY = self.user.api_key.key
config.WRITEIT_USERNAME = self.user.username
self.handler = EmailHandler()
def test_get_only_new_content_and_not_original(self):
answer = self.handler.handle(self.email)
self.assertEquals(answer.content_text, u"aass áéíóúñ")
def setUp(self):
super(BouncedMailInAmazonBug, self).setUp()
self.message = Message.objects.get(id=1)
self.contact = Contact.objects.get(value="*****@*****.**")
self.outbound_message = OutboundMessage.objects.create(message=self.message, contact=self.contact)
identifier = OutboundMessageIdentifier.objects.get(outbound_message=self.outbound_message)
identifier.key = "4aaaabbb"
identifier.save()
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail2.txt') as f:
self.bounced_email += f.read()
f.close()
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
self.answer = self.handler.handle(self.bounced_email)
self.answer.send_back()
class ReplyHandlerTestCase(ResourceTestCase):
def setUp(self):
super(ReplyHandlerTestCase, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/reply_mail.txt')
self.email = f.readlines()
f.close()
self.where_to_post_creation_of_the_answer = 'http://localhost:8000/api/v1/create_answer/'
config.WRITEIT_API_ANSWER_CREATION = self.where_to_post_creation_of_the_answer
config.WRITEIT_API_KEY = self.user.api_key.key
config.WRITEIT_USERNAME = self.user.username
self.handler = EmailHandler()
def test_get_only_new_content_and_not_original(self):
answer = self.handler.handle(self.email)
self.assertEquals(answer.content_text, u"aass áéíóúñ")
class BouncedMessageRecordTestCase(TestCase):
def setUp(self):
super(BouncedMessageRecordTestCase, self).setUp()
self.outbound_message = OutboundMessage.objects.get(id=1)
self.identifier = OutboundMessageIdentifier.objects.first()
self.identifier.key = '4aaaabbb'
self.identifier.save()
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail2.txt') as f:
self.bounced_email += f.read()
f.close()
self.bounced_email.replace(self.identifier.key, '')
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
def test_creation(self):
bounced_message = BouncedMessageRecord.objects.create(
outbound_message=self.outbound_message,
bounce_text=self.bounced_email,
)
self.assertTrue(bounced_message)
self.assertEquals(bounced_message.outbound_message,
self.outbound_message)
self.assertFalse(bounced_message.date is None)
self.assertEquals(bounced_message.bounce_text, self.bounced_email)
def test_it_creates_a_bounced_message_when_comes_a_new_bounce(self):
email_answer = self.handler.handle(self.bounced_email)
identifier = OutboundMessageIdentifier.objects.get(
key=email_answer.outbound_message_identifier)
outbound_message = OutboundMessage.objects.get(
outboundmessageidentifier=identifier)
email_answer.send_back()
bounced_messages = BouncedMessageRecord.objects.filter(
outbound_message=outbound_message)
self.assertEquals(bounced_messages.count(), 1)
bounced_message = bounced_messages[0]
self.assertEquals(bounced_message.bounce_text,
email_answer.content_text)
class DoesNotIncludeTheIdentifierInTheContent(TestCase):
def setUp(self):
super(DoesNotIncludeTheIdentifierInTheContent, self).setUp()
self.user = User.objects.get(id=1)
f = open(
'mailit/tests/fixture/mail_with_identifier_in_the_content.txt')
self.email = f.readlines()
f.close()
self.where_to_post_creation_of_the_answer = 'http://*****:*****@mailit.ciudadanointeligente.org",
self.answer.content_text)
with patch('requests.Session.post') as post:
post.return_value = PostMock()
self.answer.send_back()
post.assert_called_with(self.where_to_post_creation_of_the_answer,
data=data,
headers=expected_headers)
def test_temporary_failure_raises_temp_fail_error(self):
handler = EmailHandler(answer_class=AnswerForManageCommand)
with self.assertRaises(TemporaryFailure):
handler.handle(temporary_fail_mock())
class ResendOutboundMessages(TestCase):
def setUp(self):
super(ResendOutboundMessages, self).setUp()
self.contact = Contact.objects.get(
value="*****@*****.**")
self.contact.is_bounced = True
self.contact.save()
self.outbound_messages = OutboundMessage.objects.filter(
contact=self.contact)
for outbound_message in self.outbound_messages:
outbound_message.send()
outbound_message.status = "error"
outbound_message.save()
identifier = OutboundMessageIdentifier.objects.get(
outbound_message=outbound_message)
identifier.key = "4aaaabbb"
#This might fail if there are more than one outbound message!!!
identifier.save()
#This might fail if there are more than one outbound message!!
#please fix if necesary by only choosing the first one or by using a try - except
self.previous_amount_of_mails = len(mail.outbox)
self.bounced_email = ""
with open('mailit/tests/fixture/bounced_mail.txt') as f:
self.bounced_email += f.read()
f.close()
self.handler = EmailHandler(answer_class=AnswerForManageCommand)
self.answer = self.handler.handle(self.bounced_email)
self.answer.send_back()
def test_resend_outbound_messages(self):
self.contact.resend_messages()
outbound_messages = OutboundMessage.objects.filter(
contact=self.contact)
current_amount_of_mails_sent_after_resend_messages = len(mail.outbox)
self.assertEquals(
current_amount_of_mails_sent_after_resend_messages -
self.previous_amount_of_mails, outbound_messages.count())
for outbound_message in outbound_messages:
self.assertEquals(outbound_message.status, "sent")
def test_resends_only_failed_outbound_messages(self):
message = Message.objects.get(id=1)
OutboundMessage.objects.create(message=message,
contact=self.contact,
status="ready",
site=Site.objects.get_current())
self.contact.resend_messages()
current_amount_of_mails_sent_after_resend_messages = len(mail.outbox)
self.assertEquals(
current_amount_of_mails_sent_after_resend_messages -
self.previous_amount_of_mails, self.outbound_messages.count())
def test_it_sets_the_is_bounced_status_to_false_of_the_contact(self):
self.contact.resend_messages()
contact = Contact.objects.get(id=self.contact.id)
self.assertFalse(contact.is_bounced)
class IncomingEmailHandlerTestCase(ResourceTestCase):
def setUp(self):
super(IncomingEmailHandlerTestCase, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/mail.txt')
self.email = f.readlines()
f.close()
self.where_to_post_creation_of_the_answer = 'http://*****:*****@ciudadanointeligente.cl>')
def test_gets_when_it_was_sent(self):
self.answer = self.handler.handle(self.email)
self.assertEquals(self.answer.when, 'Wed, 26 Jun 2013 17:05:30 -0400')
def test_it_posts_to_the_api(self):
self.answer = self.handler.handle(self.email)
self.assertEquals(self.answer.requests_session.auth.api_key, self.user.api_key.key)
self.assertEquals(self.answer.requests_session.auth.username, self.user.username)
expected_headers = {'content-type': 'application/json'}
data = {
'key': self.answer.outbound_message_identifier,
'content': self.answer.content_text,
'format': 'json'
}
data = json.dumps(data)
with patch('requests.Session.post') as post:
post.return_value = PostMock()
self.answer.send_back()
post.assert_called_with(self.where_to_post_creation_of_the_answer, data=data, headers=expected_headers)
def test_it_posts_to_the_api_using_the_method_post_to_the_api(self):
self.answer = self.handler.handle(self.email)
self.assertEquals(self.answer.requests_session.auth.api_key, self.user.api_key.key)
self.assertEquals(self.answer.requests_session.auth.username, self.user.username)
expected_headers = {'content-type': 'application/json'}
data = {
'key': self.answer.outbound_message_identifier,
'content': self.answer.content_text,
'format': 'json',
}
data = json.dumps(data)
with patch('requests.Session.post') as post:
post.return_value = PostMock()
self.answer.save()
post.assert_called_with(self.where_to_post_creation_of_the_answer, data=data, headers=expected_headers)
def test_reports_a_bounce_if_it_is_a_bounce_and_does_not_post_to_the_api(self):
f = open('mailit/tests/fixture/bounced_mail2.txt')
bounce = f.readlines()
f.close()
self.answer = self.handler.handle(bounce)
where_to_post_a_bounce = 'http://writeit.ciudadanointeligente.org/api/v1/handle_bounce/'
config.WRITEIT_API_WHERE_TO_REPORT_A_BOUNCE = where_to_post_a_bounce
self.assertEquals(self.answer.requests_session.auth.api_key, self.user.api_key.key)
self.assertEquals(self.answer.requests_session.auth.username, self.user.username)
expected_headers = {'content-type': 'application/json'}
data = {'key': self.answer.outbound_message_identifier}
data = json.dumps(data)
with patch('requests.Session.post') as post:
post.return_value = PostMock()
self.answer.send_back()
post.assert_called_with(where_to_post_a_bounce, data=data, headers=expected_headers)
def test_logs_the_result_of_send_back(self):
email_answer = EmailAnswer()
email_answer.subject = 'prueba4'
email_answer.content_text = 'prueba4lafieritaespeluda'
email_answer.outbound_message_identifier = '8974aabsdsfierapulgosa'
email_answer.email_from = '*****@*****.**'
email_answer.when = 'Wed Jun 26 21:05:33 2013'
with patch('logging.info') as info:
info.return_value = None
with patch('requests.Session.post') as post:
post.return_value = PostMock()
with patch('logging.info') as info:
expected_log = "When sent to %(location)s the status code was 201" % {
'location': self.where_to_post_creation_of_the_answer
}
email_answer.send_back()
info.assert_called_with(expected_log)
def test_logs_the_incoming_email(self):
with patch('logging.info') as info:
info.return_value = None
self.answer = self.handler.handle(self.email)
expected_log = 'New incoming email from %(from)s sent on %(date)s with subject %(subject)s and content %(content)s'
expected_log = expected_log % {
'from': self.answer.email_from,
'date': self.answer.when,
'subject': self.answer.subject,
'content': self.answer.content_text,
}
info.assert_called_with(expected_log)
def test_gets_the_message_id(self):
'''The answer gets the message id'''
self.answer = self.handler.handle(self.email)
self.assertEquals(self.answer.message_id, '<CAA5PczfGfdhf29wgK=8t6j7hm8HYsBy8Qg87iTU2pF42Ez3VcQ@mail.gmail.com>')
def test_send_back_also_returns_an_answer(self):
'''the method EmailAnswer.send_back returns an answer'''
email_answer = EmailAnswer()
email_answer.subject = 'prueba4'
email_answer.content_text = 'prueba4lafieritaespeluda'
email_answer.outbound_message_identifier = '8974aabsdsfierapulgosa'
email_answer.email_from = '*****@*****.**'
email_answer.when = 'Wed Jun 26 21:05:33 2013'
# so when I execute email_answer.save, it will return
# the first answer that we have in our fixtures
# it doesn't really matter as long as it returns an answer
answer = Answer.objects.first()
with patch('requests.Session.post') as post:
post.return_value = PostMock()
with patch('mailit.bin.handleemail.EmailAnswer.save') as save_answer:
save_answer.return_value = answer
result = email_answer.send_back()
self.assertEquals(result, answer)
def test_temporary_failure_raises_temp_fail_error(self):
handler = EmailHandler(answer_class=OutboundMessageAnswer)
with self.assertRaises(TemporaryFailure):
handler.handle(temporary_fail_mock())
def test_temporary_failure_raises_temp_fail_error(self):
handler = EmailHandler(answer_class=AnswerForManageCommand)
with self.assertRaises(TemporaryFailure):
handler.handle(temporary_fail_mock())
class IncomingEmailHandlerTestCase(ResourceTestCase):
def setUp(self):
super(IncomingEmailHandlerTestCase, self).setUp()
self.user = User.objects.get(id=1)
f = open('mailit/tests/fixture/mail.txt')
self.email = f.readlines()
f.close()
self.where_to_post_creation_of_the_answer = 'http://*****:*****@ciudadanointeligente.cl>'
)
def test_gets_when_it_was_sent(self):
self.answer = self.handler.handle(self.email)
self.assertEquals(self.answer.when, 'Wed, 26 Jun 2013 17:05:30 -0400')
def test_it_posts_to_the_api(self):
self.answer = self.handler.handle(self.email)
self.assertEquals(self.answer.requests_session.auth.api_key,
self.user.api_key.key)
self.assertEquals(self.answer.requests_session.auth.username,
self.user.username)
expected_headers = {'content-type': 'application/json'}
data = {
'key': self.answer.outbound_message_identifier,
'content': self.answer.content_text,
'format': 'json'
}
data = json.dumps(data)
with patch('requests.Session.post') as post:
post.return_value = PostMock()
self.answer.send_back()
post.assert_called_with(self.where_to_post_creation_of_the_answer,
data=data,
headers=expected_headers)
def test_it_posts_to_the_api_using_the_method_post_to_the_api(self):
self.answer = self.handler.handle(self.email)
self.assertEquals(self.answer.requests_session.auth.api_key,
self.user.api_key.key)
self.assertEquals(self.answer.requests_session.auth.username,
self.user.username)
expected_headers = {'content-type': 'application/json'}
data = {
'key': self.answer.outbound_message_identifier,
'content': self.answer.content_text,
'format': 'json',
}
data = json.dumps(data)
with patch('requests.Session.post') as post:
post.return_value = PostMock()
self.answer.save()
post.assert_called_with(self.where_to_post_creation_of_the_answer,
data=data,
headers=expected_headers)
def test_reports_a_bounce_if_it_is_a_bounce_and_does_not_post_to_the_api(
self):
f = open('mailit/tests/fixture/bounced_mail2.txt')
bounce = f.readlines()
f.close()
self.answer = self.handler.handle(bounce)
where_to_post_a_bounce = 'http://writeit.ciudadanointeligente.org/api/v1/handle_bounce/'
config.WRITEIT_API_WHERE_TO_REPORT_A_BOUNCE = where_to_post_a_bounce
self.assertEquals(self.answer.requests_session.auth.api_key,
self.user.api_key.key)
self.assertEquals(self.answer.requests_session.auth.username,
self.user.username)
expected_headers = {'content-type': 'application/json'}
data = {'key': self.answer.outbound_message_identifier}
data = json.dumps(data)
with patch('requests.Session.post') as post:
post.return_value = PostMock()
self.answer.send_back()
post.assert_called_with(where_to_post_a_bounce,
data=data,
headers=expected_headers)
def test_logs_the_result_of_send_back(self):
email_answer = EmailAnswer()
email_answer.subject = 'prueba4'
email_answer.content_text = 'prueba4lafieritaespeluda'
email_answer.outbound_message_identifier = '8974aabsdsfierapulgosa'
email_answer.email_from = '*****@*****.**'
email_answer.when = 'Wed Jun 26 21:05:33 2013'
with patch('logging.info') as info:
info.return_value = None
with patch('requests.Session.post') as post:
post.return_value = PostMock()
with patch('logging.info') as info:
expected_log = "When sent to %(location)s the status code was 201" % {
'location': self.where_to_post_creation_of_the_answer
}
email_answer.send_back()
info.assert_called_with(expected_log)
def test_logs_the_incoming_email(self):
with patch('logging.info') as info:
info.return_value = None
self.answer = self.handler.handle(self.email)
expected_log = 'New incoming email from %(from)s sent on %(date)s with subject %(subject)s and content %(content)s'
expected_log = expected_log % {
'from': self.answer.email_from,
'date': self.answer.when,
'subject': self.answer.subject,
'content': self.answer.content_text,
}
info.assert_called_with(expected_log)
def test_gets_the_message_id(self):
'''The answer gets the message id'''
self.answer = self.handler.handle(self.email)
self.assertEquals(
self.answer.message_id,
'<CAA5PczfGfdhf29wgK=8t6j7hm8HYsBy8Qg87iTU2pF42Ez3VcQ@mail.gmail.com>'
)
def test_send_back_also_returns_an_answer(self):
'''the method EmailAnswer.send_back returns an answer'''
email_answer = EmailAnswer()
email_answer.subject = 'prueba4'
email_answer.content_text = 'prueba4lafieritaespeluda'
email_answer.outbound_message_identifier = '8974aabsdsfierapulgosa'
email_answer.email_from = '*****@*****.**'
email_answer.when = 'Wed Jun 26 21:05:33 2013'
# so when I execute email_answer.save, it will return
# the first answer that we have in our fixtures
# it doesn't really matter as long as it returns an answer
answer = Answer.objects.first()
with patch('requests.Session.post') as post:
post.return_value = PostMock()
with patch(
'mailit.bin.handleemail.EmailAnswer.save') as save_answer:
save_answer.return_value = answer
result = email_answer.send_back()
self.assertEquals(result, answer)
class EmailReadingExamplesTestCase(TestCase):
def setUp(self):
super(EmailReadingExamplesTestCase, self).setUp()
self.message = Message.objects.get(id=1)
self.contact = Contact.objects.get(
value="*****@*****.**")
self.outbound_message = OutboundMessage.objects.create(
message=self.message,
contact=self.contact,
site=Site.objects.get_current())
self.outbound_message.send()
identifier = OutboundMessageIdentifier.objects.get(
outbound_message=self.outbound_message)
identifier.key = "7e460e9c462411e38ef81231400178dd"
identifier.save()
self.handler = EmailHandler()
def test_example1_gmail(self):
f = open('mailit/tests/fixture/example1_gmail.txt')
email = f.readlines()
f.close()
answer = self.handler.handle(email)
self.assertEquals(answer.content_text, u"si prueba no más")
self.assertIn(u"si prueba no más", answer.content_html)
@skip(
"this fails because it still has some parts from the origina email, probably this is not easy taken away"
)
def test_example2_gmail(self):
f = open('mailit/tests/fixture/example2_gmail.txt')
email = f.readlines()
f.close()
answer = self.handler.handle(email)
self.assertEquals(answer.content_text, u"de nuevo de nuevo")
def test_example3_ipad(self):
f = open('mailit/tests/fixture/example3_ipad.txt')
email = f.readlines()
f.close()
answer = self.handler.handle(email)
self.assertEquals(
answer.content_text,
u"Primero que todo los felicito por la iniciativa , ojalá lleguen más preguntas ."
)
def test_example4_hotmail(self):
f = open('mailit/tests/fixture/example4_hotmail.txt')
email = f.readlines()
f.close()
answer = self.handler.handle(email)
self.assertIn(
u"chilen@ está ausente más de 10 horas de su hogar despreocup",
answer.content_text)
def test_example5_michellebachelet(self):
f = open('mailit/tests/fixture/example5_michellebachelet.txt')
email = f.readlines()
f.close()
answer = self.handler.handle(email)
self.assertIn(u"Realizaremos un proceso de consulta con los Pueblos",
answer.content_text)
