class TestMailService(unittest.TestCase):
def setUp(self):
self.drafts = mock()
self.querier = mock()
self.mail_store = mock()
self.mailboxes = mock()
self.mailboxes.drafts = defer.succeed(self.drafts)
self.mailboxes.trash = mock()
self.mailboxes.sent = mock()
self.mail_sender = mock()
self.search_engine = mock()
self.mail_service = MailService(self.mailboxes, self.mail_sender, self.mail_store, self.querier, self.search_engine)
def tearDown(self):
unstub()
def test_send_mail(self):
when(InputMail).from_dict(ANY()).thenReturn('inputmail')
when(self.mail_sender).sendmail(ANY()).thenReturn(defer.Deferred())
sent_deferred = self.mail_service.send_mail(mail_dict())
verify(self.mail_sender).sendmail("inputmail")
sent_deferred.callback('Assume sending mail succeeded')
return sent_deferred
@defer.inlineCallbacks
def test_send_mail_removes_draft(self):
mail = mock()
when(mail).raw = 'raw mail'
when(InputMail).from_dict(ANY()).thenReturn(mail)
when(self.mail_store).delete_mail('12').thenReturn(defer.succeed(None))
when(self.mail_store).add_mail('SENT', ANY()).thenReturn(defer.succeed(None))
deferred_success = defer.succeed(None)
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_success)
yield self.mail_service.send_mail({'ident': '12'})
verify(self.mail_sender).sendmail(mail)
verify(self.mail_store).add_mail('SENT', 'raw mail')
verify(self.mail_store).delete_mail('12')
@defer.inlineCallbacks
def test_send_mail_does_not_delete_draft_on_error(self):
when(InputMail).from_dict(ANY()).thenReturn('inputmail')
deferred_failure = defer.fail(Exception("Assume sending mail failed"))
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_failure)
try:
yield self.mail_service.send_mail({'ident': '12'})
self.fail("send_mail is expected to raise if underlying call fails")
except:
verify(self.mail_sender).sendmail("inputmail")
verifyNoMoreInteractions(self.drafts)
@defer.inlineCallbacks
def test_mark_as_read(self):
mail = LeapMail('id', 'INBOX')
when(self.mail_store).get_mail(ANY(), include_body=True).thenReturn(mail)
yield self.mail_service.mark_as_read(1)
self.assertIn(Status.SEEN, mail.flags)
verify(self.mail_store).update_mail(mail)
@defer.inlineCallbacks
def test_delete_mail(self):
mail_to_delete = LeapMail(1, 'INBOX')
when(self.mail_store).get_mail(1, include_body=True).thenReturn(defer.succeed(mail_to_delete))
yield self.mail_service.delete_mail(1)
verify(self.mail_store).move_mail_to_mailbox(1, 'TRASH')
def test_recover_mail(self):
mail_to_recover = PixelatedMail.from_soledad(*leap_mail(), soledad_querier=None)
when(self.mail_service).mail(1).thenReturn(mail_to_recover)
when(self.mailboxes).move_to_inbox(1).thenReturn(mail_to_recover)
self.mail_service.recover_mail(1)
verify(self.mailboxes).move_to_inbox(1)
verify(self.search_engine).index_mail(mail_to_recover)
class TestMailService(unittest.TestCase):
def setUp(self):
self.drafts = mock()
self.querier = mock()
self.mailboxes = mock()
self.mailboxes.drafts = lambda: self.drafts
self.mailboxes.trash = lambda: mock()
self.mailboxes.sent = lambda: mock()
self.mail_sender = mock()
self.search_engine = mock()
self.mail_service = MailService(self.mailboxes, self.mail_sender,
self.querier, self.search_engine)
def tearDown(self):
unstub()
def test_send_mail(self):
when(InputMail).from_dict(any()).thenReturn('inputmail')
when(self.mail_sender).sendmail(any()).thenReturn(Deferred())
sent_deferred = self.mail_service.send_mail(mail_dict())
verify(self.mail_sender).sendmail("inputmail")
sent_deferred.callback('Assume sending mail succeeded')
return sent_deferred
def test_send_mail_removes_draft(self):
mail_ident = 'Some ident'
mail = mail_dict()
mail['ident'] = mail_ident
when(InputMail).from_dict(any()).thenReturn('inputmail')
deferred = Deferred()
when(self.mail_sender).sendmail(any()).thenReturn(deferred)
sent_deferred = self.mail_service.send_mail(mail)
verify(self.mail_sender).sendmail("inputmail")
def assert_removed_from_drafts(_):
verify(self.drafts).remove(any())
sent_deferred.addCallback(assert_removed_from_drafts)
sent_deferred.callback('Assume sending mail succeeded')
return sent_deferred
def test_send_mail_does_not_delete_draft_on_error(self):
when(InputMail).from_dict(any()).thenReturn('inputmail')
when(self.mail_sender).sendmail(any()).thenReturn(Deferred())
send_deferred = self.mail_service.send_mail(mail_dict())
verify(self.mail_sender).sendmail("inputmail")
def assert_not_removed_from_drafts(_):
verifyNoMoreInteractions(self.drafts)
send_deferred.addErrback(assert_not_removed_from_drafts)
send_deferred.errback(Exception('Assume sending mail failed'))
return send_deferred
def test_mark_as_read(self):
mail = mock()
when(self.mail_service).mail(any()).thenReturn(mail)
self.mail_service.mark_as_read(1)
verify(mail).mark_as_read()
def test_delete_mail(self):
mail_to_delete = PixelatedMail.from_soledad(*leap_mail(),
soledad_querier=None)
when(self.mail_service).mail(1).thenReturn(mail_to_delete)
self.mail_service.delete_mail(1)
verify(self.mailboxes).move_to_trash(1)
def test_recover_mail(self):
mail_to_recover = PixelatedMail.from_soledad(*leap_mail(),
soledad_querier=None)
when(self.mail_service).mail(1).thenReturn(mail_to_recover)
when(self.mailboxes).move_to_inbox(1).thenReturn(mail_to_recover)
self.mail_service.recover_mail(1)
verify(self.mailboxes).move_to_inbox(1)
verify(self.search_engine).index_mail(mail_to_recover)
class TestMailService(unittest.TestCase):
def setUp(self):
self.drafts = mock()
self.mail_store = mock()
self.mailboxes = mock()
self.mailboxes.drafts = defer.succeed(self.drafts)
self.mailboxes.trash = mock()
self.mailboxes.sent = mock()
self.mail_sender = mock()
self.search_engine = mock()
self.mail_service = MailService(self.mail_sender, self.mail_store,
self.search_engine)
def tearDown(self):
unstub()
def test_send_mail(self):
when(InputMail).from_dict(ANY()).thenReturn('inputmail')
when(self.mail_sender).sendmail(ANY()).thenReturn(defer.Deferred())
sent_deferred = self.mail_service.send_mail(mail_dict())
verify(self.mail_sender).sendmail("inputmail")
sent_deferred.callback('Assume sending mail succeeded')
return sent_deferred
@defer.inlineCallbacks
def test_send_mail_removes_draft(self):
mail = LeapMail('id', 'INBOX')
when(mail).raw = 'raw mail'
when(InputMail).from_dict(ANY()).thenReturn(mail)
when(self.mail_store).delete_mail('12').thenReturn(defer.succeed(None))
when(self.mail_store).add_mail('SENT', ANY()).thenReturn(mail)
deferred_success = defer.succeed(None)
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_success)
yield self.mail_service.send_mail({'ident': '12'})
verify(self.mail_sender).sendmail(mail)
verify(self.mail_store).add_mail('SENT', mail.raw)
verify(self.mail_store).delete_mail('12')
@defer.inlineCallbacks
def test_send_mail_marks_as_read(self):
mail = LeapMail('id', 'INBOX')
when(mail).raw = 'raw mail'
when(InputMail).from_dict(ANY()).thenReturn(mail)
when(self.mail_store).delete_mail('12').thenReturn(defer.succeed(None))
when(self.mail_sender).sendmail(ANY()).thenReturn(defer.succeed(None))
sent_mail = LeapMail('id', 'INBOX')
add_mail_deferral = defer.succeed(sent_mail)
when(self.mail_store).add_mail('SENT',
ANY()).thenReturn(add_mail_deferral)
yield self.mail_service.send_mail({'ident': '12'})
self.assertIn(Status.SEEN, sent_mail.flags)
verify(self.mail_store).update_mail(sent_mail)
@defer.inlineCallbacks
def test_send_mail_does_not_delete_draft_on_error(self):
when(InputMail).from_dict(ANY()).thenReturn('inputmail')
deferred_failure = defer.fail(Exception("Assume sending mail failed"))
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_failure)
try:
yield self.mail_service.send_mail({'ident': '12'})
self.fail(
"send_mail is expected to raise if underlying call fails")
except:
verify(self.mail_sender).sendmail("inputmail")
verifyNoMoreInteractions(self.drafts)
@defer.inlineCallbacks
def test_mark_as_read(self):
mail = LeapMail(1, 'INBOX')
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
yield self.mail_service.mark_as_read(1)
self.assertIn(Status.SEEN, mail.flags)
verify(self.mail_store).update_mail(mail)
@defer.inlineCallbacks
def test_mark_as_unread(self):
mail = LeapMail(1, 'INBOX')
mail.flags.add(Status.SEEN)
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
yield self.mail_service.mark_as_unread(1)
verify(self.mail_store).update_mail(mail)
self.assertNotEqual(mail.status, Status.SEEN)
@defer.inlineCallbacks
def test_delete_mail(self):
mail_to_delete = LeapMail(1, 'INBOX')
when(self.mail_store).get_mail(1, include_body=True).thenReturn(
defer.succeed(mail_to_delete))
yield self.mail_service.delete_mail(1)
verify(self.mail_store).move_mail_to_mailbox(1, 'TRASH')
@defer.inlineCallbacks
def test_recover_mail(self):
mail_to_recover = LeapMail(1, 'TRASH')
when(self.mail_service).mail(1).thenReturn(mail_to_recover)
when(self.mail_store).move_mail_to_mailbox(
1, 'INBOX').thenReturn(mail_to_recover)
yield self.mail_service.recover_mail(1)
verify(self.mail_store).move_mail_to_mailbox(1, 'INBOX')
@defer.inlineCallbacks
def test_get_attachment(self):
attachment_dict = {
'content': bytearray('data'),
'content-type': 'text/plain'
}
when(self.mail_store).get_mail_attachment(
'some attachment id').thenReturn(defer.succeed(attachment_dict))
attachment = yield self.mail_service.attachment('some attachment id')
self.assertEqual(attachment_dict, attachment)
@defer.inlineCallbacks
def test_update_tags_return_a_set_with_the_current_tags(self):
mail = LeapMail(1, 'INBOX', tags={'custom_1', 'custom_2'})
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
when(self.search_engine).tags(query='',
skip_default_tags=True).thenReturn([])
updated_mail = yield self.mail_service.update_tags(
1, {'custom_1', 'custom_3'})
verify(self.mail_store).update_mail(mail)
self.assertEqual({'custom_1', 'custom_3'}, updated_mail.tags)
class TestMailService(unittest.TestCase):
def setUp(self):
self.drafts = mock()
self.mail_store = mock()
self.attachment_store = mock()
self.mailboxes = mock()
self.mailboxes.drafts = defer.succeed(self.drafts)
self.mailboxes.trash = mock()
self.mailboxes.sent = mock()
self.mail_sender = mock()
self.search_engine = mock()
self.mail_service = MailService(self.mail_sender, self.mail_store, self.search_engine, 'acount@email', self.attachment_store)
self.mail = InputMail.from_dict(duplicates_in_fields_mail_dict(), from_address='pixelated@org')
def tearDown(self):
unstub()
def test_send_mail(self):
when(InputMail).from_dict(ANY(), ANY()).thenReturn(self.mail)
when(self.mail_sender).sendmail(ANY()).thenReturn(defer.Deferred())
sent_deferred = self.mail_service.send_mail(mail_dict())
verify(self.mail_sender).sendmail(self.mail)
sent_deferred.callback('Assume sending mail succeeded')
return sent_deferred
@defer.inlineCallbacks
def test_send_mail_removes_draft(self):
mail = LeapMail('id', 'INBOX')
when(mail).raw = 'raw mail'
mail._headers['To'] = []
mail._headers['Cc'] = []
mail._headers['Bcc'] = []
when(InputMail).from_dict(ANY(), ANY()).thenReturn(mail)
when(self.mail_store).delete_mail('12').thenReturn(defer.succeed(None))
when(self.mail_store).add_mail('SENT', ANY()).thenReturn(mail)
deferred_success = defer.succeed(None)
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_success)
yield self.mail_service.send_mail({'ident': '12'})
verify(self.mail_sender).sendmail(mail)
verify(self.mail_store).add_mail('SENT', mail.raw)
verify(self.mail_store).delete_mail('12')
@defer.inlineCallbacks
def test_send_mail_marks_as_read(self):
when(self.mail).raw = 'raw mail'
when(InputMail).from_dict(ANY(), ANY()).thenReturn(self.mail)
when(self.mail_store).delete_mail('12').thenReturn(defer.succeed(None))
when(self.mail_sender).sendmail(self.mail).thenReturn(defer.succeed(None))
sent_mail = LeapMail('id', 'INBOX')
add_mail_deferral = defer.succeed(sent_mail)
when(self.mail_store).add_mail('SENT', ANY()).thenReturn(add_mail_deferral)
yield self.mail_service.send_mail({'ident': '12'})
self.assertIn(Status.SEEN, sent_mail.flags)
verify(self.mail_store).update_mail(sent_mail)
@defer.inlineCallbacks
def test_send_mail_does_not_delete_draft_on_error(self):
when(InputMail).from_dict(ANY(), ANY()).thenReturn(self.mail)
deferred_failure = defer.fail(Exception("Assume sending mail failed"))
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_failure)
try:
yield self.mail_service.send_mail({'ident': '12'})
self.fail("send_mail is expected to raise if underlying call fails")
except:
verify(self.mail_sender).sendmail(self.mail)
verifyNoMoreInteractions(self.drafts)
@defer.inlineCallbacks
def test_mark_as_read(self):
mail = LeapMail(1, 'INBOX')
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
yield self.mail_service.mark_as_read(1)
self.assertIn(Status.SEEN, mail.flags)
verify(self.mail_store).update_mail(mail)
@defer.inlineCallbacks
def test_mark_as_unread(self):
mail = LeapMail(1, 'INBOX')
mail.flags.add(Status.SEEN)
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
yield self.mail_service.mark_as_unread(1)
verify(self.mail_store).update_mail(mail)
self.assertNotEqual(mail.status, Status.SEEN)
@defer.inlineCallbacks
def test_delete_mail(self):
mail_to_delete = LeapMail(1, 'INBOX')
when(self.mail_store).get_mail(1, include_body=True).thenReturn(defer.succeed(mail_to_delete))
yield self.mail_service.delete_mail(1)
verify(self.mail_store).move_mail_to_mailbox(1, 'TRASH')
@defer.inlineCallbacks
def test_delete_mail_does_not_fail_for_invalid_mail(self):
no_mail = None
mail_id = 1
when(self.mail_store).get_mail(mail_id, include_body=True).thenReturn(defer.succeed(no_mail))
yield self.mail_service.delete_mail(mail_id)
verify(self.mail_store, never).delete_mail(mail_id)
verify(self.mail_store, never).move_mail_to_mailbox(mail_id, ANY())
@defer.inlineCallbacks
def test_recover_mail(self):
mail_to_recover = LeapMail(1, 'TRASH')
when(self.mail_service).mail(1).thenReturn(mail_to_recover)
when(self.mail_store).move_mail_to_mailbox(1, 'INBOX').thenReturn(mail_to_recover)
yield self.mail_service.recover_mail(1)
verify(self.mail_store).move_mail_to_mailbox(1, 'INBOX')
@defer.inlineCallbacks
def test_get_attachment(self):
attachment_dict = {'content': bytearray('data'), 'content-type': 'text/plain'}
when(self.attachment_store).get_mail_attachment('some attachment id').thenReturn(defer.succeed(attachment_dict))
attachment = yield self.mail_service.attachment('some attachment id')
self.assertEqual(attachment_dict, attachment)
@defer.inlineCallbacks
def test_update_tags_return_a_set_with_the_current_tags(self):
mail = LeapMail(1, 'INBOX', tags={'custom_1', 'custom_2'})
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
when(self.search_engine).tags(query='', skip_default_tags=True).thenReturn([])
updated_mail = yield self.mail_service.update_tags(1, {'custom_1', 'custom_3'})
verify(self.mail_store).update_mail(mail)
self.assertEqual({'custom_1', 'custom_3'}, updated_mail.tags)
@defer.inlineCallbacks
def test_if_recipient_doubled_in_fields_send_only_in_bcc(self):
mail = InputMail.from_dict(duplicates_in_fields_mail_dict(), from_address='pixelated@org')
yield self.mail_service._deduplicate_recipients(mail)
self.assertIn('*****@*****.**', mail.to)
self.assertNotIn('*****@*****.**', mail.to)
self.assertIn('*****@*****.**', mail.bcc)
@defer.inlineCallbacks
def test_if_recipient_doubled_in_fields_send_only_in_to(self):
mail = InputMail.from_dict(duplicates_in_fields_mail_dict(), from_address='pixelated@org')
yield self.mail_service._deduplicate_recipients(mail)
self.assertIn('*****@*****.**', mail.to)
self.assertNotIn('*****@*****.**', mail.cc)
self.assertIn('*****@*****.**', mail.cc)
self.assertNotIn('*****@*****.**', mail.cc)
@defer.inlineCallbacks
def test_if_deduplicates_when_recipient_repeated_in_field(self):
mail = InputMail.from_dict(duplicates_in_fields_mail_dict(), from_address='pixelated@org')
yield self.mail_service._deduplicate_recipients(mail)
self.assertItemsEqual(['*****@*****.**', '*****@*****.**'], mail.bcc)
self.assertItemsEqual(['*****@*****.**', '*****@*****.**'], mail.to)
self.assertItemsEqual(['*****@*****.**'], mail.cc)
def test_remove_canonical_recipient_when_it_is_not_canonical(self):
recipient = u'*****@*****.**'
non_canonical = self.mail_service._remove_canonical_recipient(recipient)
self.assertEqual(recipient, non_canonical)
def test_remove_canonical_recipient_when_it_is_canonical(self):
recipient = u'User <*****@*****.**>'
non_canonical = self.mail_service._remove_canonical_recipient(recipient)
self.assertEqual(u'*****@*****.**', non_canonical)
class TestMailService(unittest.TestCase):
def setUp(self):
self.drafts = mock()
self.querier = mock()
self.mailboxes = mock()
self.mailboxes.drafts = lambda: self.drafts
self.mailboxes.trash = lambda: mock()
self.mailboxes.sent = lambda: mock()
self.mail_sender = mock()
self.search_engine = mock()
self.mail_service = MailService(self.mailboxes, self.mail_sender, self.querier, self.search_engine)
def tearDown(self):
unstub()
def test_send_mail(self):
when(InputMail).from_dict(any()).thenReturn('inputmail')
when(self.mail_sender).sendmail(any()).thenReturn(Deferred())
sent_deferred = self.mail_service.send_mail(mail_dict())
verify(self.mail_sender).sendmail("inputmail")
sent_deferred.callback('Assume sending mail succeeded')
return sent_deferred
def test_send_mail_removes_draft(self):
mail_ident = 'Some ident'
mail = mail_dict()
mail['ident'] = mail_ident
when(InputMail).from_dict(any()).thenReturn('inputmail')
deferred = Deferred()
when(self.mail_sender).sendmail(any()).thenReturn(deferred)
sent_deferred = self.mail_service.send_mail(mail)
verify(self.mail_sender).sendmail("inputmail")
def assert_removed_from_drafts(_):
verify(self.drafts).remove(any())
sent_deferred.addCallback(assert_removed_from_drafts)
sent_deferred.callback('Assume sending mail succeeded')
return sent_deferred
def test_send_mail_does_not_delete_draft_on_error(self):
when(InputMail).from_dict(any()).thenReturn('inputmail')
when(self.mail_sender).sendmail(any()).thenReturn(Deferred())
send_deferred = self.mail_service.send_mail(mail_dict())
verify(self.mail_sender).sendmail("inputmail")
def assert_not_removed_from_drafts(_):
verifyNoMoreInteractions(self.drafts)
send_deferred.addErrback(assert_not_removed_from_drafts)
send_deferred.errback(Exception('Assume sending mail failed'))
return send_deferred
def test_mark_as_read(self):
mail = mock()
when(self.mail_service).mail(any()).thenReturn(mail)
self.mail_service.mark_as_read(1)
verify(mail).mark_as_read()
def test_delete_mail(self):
mail_to_delete = PixelatedMail.from_soledad(*leap_mail(), soledad_querier=None)
when(self.mail_service).mail(1).thenReturn(mail_to_delete)
self.mail_service.delete_mail(1)
verify(self.mailboxes).move_to_trash(1)
def test_recover_mail(self):
mail_to_recover = PixelatedMail.from_soledad(*leap_mail(), soledad_querier=None)
when(self.mail_service).mail(1).thenReturn(mail_to_recover)
when(self.mailboxes).move_to_inbox(1).thenReturn(mail_to_recover)
self.mail_service.recover_mail(1)
verify(self.mailboxes).move_to_inbox(1)
verify(self.search_engine).index_mail(mail_to_recover)
class TestMailService(unittest.TestCase):
def setUp(self):
self.drafts = mock()
self.mail_store = mock()
self.attachment_store = mock()
self.mailboxes = mock()
self.mailboxes.drafts = defer.succeed(self.drafts)
self.mailboxes.trash = mock()
self.mailboxes.sent = mock()
self.mail_sender = mock()
self.search_engine = mock()
self.mail_service = MailService(self.mail_sender, self.mail_store,
self.search_engine, 'acount@email',
self.attachment_store)
self.mail = InputMail.from_dict(duplicates_in_fields_mail_dict(),
from_address='pixelated@org')
def tearDown(self):
unstub()
def test_send_mail(self):
when(InputMail).from_dict(ANY(), ANY()).thenReturn(self.mail)
when(self.mail_sender).sendmail(ANY()).thenReturn(defer.Deferred())
sent_deferred = self.mail_service.send_mail(mail_dict())
verify(self.mail_sender).sendmail(self.mail)
sent_deferred.callback('Assume sending mail succeeded')
return sent_deferred
@defer.inlineCallbacks
def test_send_mail_removes_draft(self):
mail = LeapMail('id', 'INBOX')
when(mail).raw = 'raw mail'
mail._headers['To'] = []
mail._headers['Cc'] = []
mail._headers['Bcc'] = []
when(InputMail).from_dict(ANY(), ANY()).thenReturn(mail)
when(self.mail_store).delete_mail('12').thenReturn(defer.succeed(None))
when(self.mail_store).add_mail('SENT', ANY()).thenReturn(mail)
deferred_success = defer.succeed(None)
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_success)
yield self.mail_service.send_mail({'ident': '12'})
verify(self.mail_sender).sendmail(mail)
verify(self.mail_store).add_mail('SENT', mail.raw)
verify(self.mail_store).delete_mail('12')
@defer.inlineCallbacks
def test_send_mail_marks_as_read(self):
when(self.mail).raw = 'raw mail'
when(InputMail).from_dict(ANY(), ANY()).thenReturn(self.mail)
when(self.mail_store).delete_mail('12').thenReturn(defer.succeed(None))
when(self.mail_sender).sendmail(self.mail).thenReturn(
defer.succeed(None))
sent_mail = LeapMail('id', 'INBOX')
add_mail_deferral = defer.succeed(sent_mail)
when(self.mail_store).add_mail('SENT',
ANY()).thenReturn(add_mail_deferral)
yield self.mail_service.send_mail({'ident': '12'})
self.assertIn(Status.SEEN, sent_mail.flags)
verify(self.mail_store).update_mail(sent_mail)
@defer.inlineCallbacks
def test_send_mail_does_not_delete_draft_on_error(self):
when(InputMail).from_dict(ANY(), ANY()).thenReturn(self.mail)
deferred_failure = defer.fail(Exception("Assume sending mail failed"))
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_failure)
try:
yield self.mail_service.send_mail({'ident': '12'})
self.fail(
"send_mail is expected to raise if underlying call fails")
except:
verify(self.mail_sender).sendmail(self.mail)
verifyNoMoreInteractions(self.drafts)
@defer.inlineCallbacks
def test_mark_as_read(self):
mail = LeapMail(1, 'INBOX')
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
yield self.mail_service.mark_as_read(1)
self.assertIn(Status.SEEN, mail.flags)
verify(self.mail_store).update_mail(mail)
@defer.inlineCallbacks
def test_mark_as_unread(self):
mail = LeapMail(1, 'INBOX')
mail.flags.add(Status.SEEN)
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
yield self.mail_service.mark_as_unread(1)
verify(self.mail_store).update_mail(mail)
self.assertNotEqual(mail.status, Status.SEEN)
@defer.inlineCallbacks
def test_delete_mail(self):
mail_to_delete = LeapMail(1, 'INBOX')
when(self.mail_store).get_mail(1, include_body=True).thenReturn(
defer.succeed(mail_to_delete))
yield self.mail_service.delete_mail(1)
verify(self.mail_store).move_mail_to_mailbox(1, 'TRASH')
@defer.inlineCallbacks
def test_delete_mail_does_not_fail_for_invalid_mail(self):
no_mail = None
mail_id = 1
when(self.mail_store).get_mail(mail_id, include_body=True).thenReturn(
defer.succeed(no_mail))
yield self.mail_service.delete_mail(mail_id)
verify(self.mail_store, never).delete_mail(mail_id)
verify(self.mail_store, never).move_mail_to_mailbox(mail_id, ANY())
@defer.inlineCallbacks
def test_recover_mail(self):
mail_to_recover = LeapMail(1, 'TRASH')
when(self.mail_service).mail(1).thenReturn(mail_to_recover)
when(self.mail_store).move_mail_to_mailbox(
1, 'INBOX').thenReturn(mail_to_recover)
yield self.mail_service.recover_mail(1)
verify(self.mail_store).move_mail_to_mailbox(1, 'INBOX')
@defer.inlineCallbacks
def test_get_attachment(self):
attachment_dict = {
'content': bytearray('data'),
'content-type': 'text/plain'
}
when(self.attachment_store).get_mail_attachment(
'some attachment id').thenReturn(defer.succeed(attachment_dict))
attachment = yield self.mail_service.attachment('some attachment id')
self.assertEqual(attachment_dict, attachment)
@defer.inlineCallbacks
def test_update_tags_return_a_set_with_the_current_tags(self):
mail = LeapMail(1, 'INBOX', tags={'custom_1', 'custom_2'})
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
when(self.search_engine).tags(query='',
skip_default_tags=True).thenReturn([])
updated_mail = yield self.mail_service.update_tags(
1, {'custom_1', 'custom_3'})
verify(self.mail_store).update_mail(mail)
self.assertEqual({'custom_1', 'custom_3'}, updated_mail.tags)
@defer.inlineCallbacks
def test_if_recipient_doubled_in_fields_send_only_in_bcc(self):
mail = InputMail.from_dict(duplicates_in_fields_mail_dict(),
from_address='pixelated@org')
yield self.mail_service._deduplicate_recipients(mail)
self.assertIn('*****@*****.**', mail.to)
self.assertNotIn('*****@*****.**', mail.to)
self.assertIn('*****@*****.**', mail.bcc)
@defer.inlineCallbacks
def test_if_recipient_doubled_in_fields_send_only_in_to(self):
mail = InputMail.from_dict(duplicates_in_fields_mail_dict(),
from_address='pixelated@org')
yield self.mail_service._deduplicate_recipients(mail)
self.assertIn('*****@*****.**', mail.to)
self.assertNotIn('*****@*****.**', mail.cc)
self.assertIn('*****@*****.**', mail.cc)
self.assertNotIn('*****@*****.**', mail.cc)
@defer.inlineCallbacks
def test_if_deduplicates_when_recipient_repeated_in_field(self):
mail = InputMail.from_dict(duplicates_in_fields_mail_dict(),
from_address='pixelated@org')
yield self.mail_service._deduplicate_recipients(mail)
self.assertItemsEqual(['*****@*****.**', '*****@*****.**'],
mail.bcc)
self.assertItemsEqual(['*****@*****.**', '*****@*****.**'],
mail.to)
self.assertItemsEqual(['*****@*****.**'], mail.cc)
def test_remove_canonical_recipient_when_it_is_not_canonical(self):
recipient = u'*****@*****.**'
non_canonical = self.mail_service._remove_canonical_recipient(
recipient)
self.assertEqual(recipient, non_canonical)
def test_remove_canonical_recipient_when_it_is_canonical(self):
recipient = u'User <*****@*****.**>'
non_canonical = self.mail_service._remove_canonical_recipient(
recipient)
self.assertEqual(u'*****@*****.**', non_canonical)
class TestMailService(unittest.TestCase):
def setUp(self):
self.drafts = mock()
self.mail_store = mock()
self.mailboxes = mock()
self.mailboxes.drafts = defer.succeed(self.drafts)
self.mailboxes.trash = mock()
self.mailboxes.sent = mock()
self.mail_sender = mock()
self.search_engine = mock()
self.mail_service = MailService(self.mail_sender, self.mail_store, self.search_engine, 'acount@email')
def tearDown(self):
unstub()
def test_send_mail(self):
when(InputMail).from_dict(ANY()).thenReturn('inputmail')
when(self.mail_sender).sendmail(ANY()).thenReturn(defer.Deferred())
sent_deferred = self.mail_service.send_mail(mail_dict())
verify(self.mail_sender).sendmail("inputmail")
sent_deferred.callback('Assume sending mail succeeded')
return sent_deferred
@defer.inlineCallbacks
def test_send_mail_removes_draft(self):
mail = LeapMail('id', 'INBOX')
when(mail).raw = 'raw mail'
when(InputMail).from_dict(ANY()).thenReturn(mail)
when(self.mail_store).delete_mail('12').thenReturn(defer.succeed(None))
when(self.mail_store).add_mail('SENT', ANY()).thenReturn(mail)
deferred_success = defer.succeed(None)
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_success)
yield self.mail_service.send_mail({'ident': '12'})
verify(self.mail_sender).sendmail(mail)
verify(self.mail_store).add_mail('SENT', mail.raw)
verify(self.mail_store).delete_mail('12')
@defer.inlineCallbacks
def test_send_mail_marks_as_read(self):
mail = LeapMail('id', 'INBOX')
when(mail).raw = 'raw mail'
when(InputMail).from_dict(ANY()).thenReturn(mail)
when(self.mail_store).delete_mail('12').thenReturn(defer.succeed(None))
when(self.mail_sender).sendmail(ANY()).thenReturn(defer.succeed(None))
sent_mail = LeapMail('id', 'INBOX')
add_mail_deferral = defer.succeed(sent_mail)
when(self.mail_store).add_mail('SENT', ANY()).thenReturn(add_mail_deferral)
yield self.mail_service.send_mail({'ident': '12'})
self.assertIn(Status.SEEN, sent_mail.flags)
verify(self.mail_store).update_mail(sent_mail)
@defer.inlineCallbacks
def test_send_mail_does_not_delete_draft_on_error(self):
when(InputMail).from_dict(ANY()).thenReturn('inputmail')
deferred_failure = defer.fail(Exception("Assume sending mail failed"))
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_failure)
try:
yield self.mail_service.send_mail({'ident': '12'})
self.fail("send_mail is expected to raise if underlying call fails")
except:
verify(self.mail_sender).sendmail("inputmail")
verifyNoMoreInteractions(self.drafts)
@defer.inlineCallbacks
def test_mark_as_read(self):
mail = LeapMail(1, 'INBOX')
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
yield self.mail_service.mark_as_read(1)
self.assertIn(Status.SEEN, mail.flags)
verify(self.mail_store).update_mail(mail)
@defer.inlineCallbacks
def test_mark_as_unread(self):
mail = LeapMail(1, 'INBOX')
mail.flags.add(Status.SEEN)
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
yield self.mail_service.mark_as_unread(1)
verify(self.mail_store).update_mail(mail)
self.assertNotEqual(mail.status, Status.SEEN)
@defer.inlineCallbacks
def test_delete_mail(self):
mail_to_delete = LeapMail(1, 'INBOX')
when(self.mail_store).get_mail(1, include_body=True).thenReturn(defer.succeed(mail_to_delete))
yield self.mail_service.delete_mail(1)
verify(self.mail_store).move_mail_to_mailbox(1, 'TRASH')
@defer.inlineCallbacks
def test_recover_mail(self):
mail_to_recover = LeapMail(1, 'TRASH')
when(self.mail_service).mail(1).thenReturn(mail_to_recover)
when(self.mail_store).move_mail_to_mailbox(1, 'INBOX').thenReturn(mail_to_recover)
yield self.mail_service.recover_mail(1)
verify(self.mail_store).move_mail_to_mailbox(1, 'INBOX')
@defer.inlineCallbacks
def test_get_attachment(self):
attachment_dict = {'content': bytearray('data'), 'content-type': 'text/plain'}
when(self.mail_store).get_mail_attachment('some attachment id').thenReturn(defer.succeed(attachment_dict))
attachment = yield self.mail_service.attachment('some attachment id')
self.assertEqual(attachment_dict, attachment)
@defer.inlineCallbacks
def test_update_tags_return_a_set_with_the_current_tags(self):
mail = LeapMail(1, 'INBOX', tags={'custom_1', 'custom_2'})
when(self.mail_store).get_mail(1, include_body=True).thenReturn(mail)
when(self.search_engine).tags(query='', skip_default_tags=True).thenReturn([])
updated_mail = yield self.mail_service.update_tags(1, {'custom_1', 'custom_3'})
verify(self.mail_store).update_mail(mail)
self.assertEqual({'custom_1', 'custom_3'}, updated_mail.tags)
class TestMailService(unittest.TestCase):
def setUp(self):
self.drafts = mock()
self.querier = mock()
self.mail_store = mock()
self.mailboxes = mock()
self.mailboxes.drafts = defer.succeed(self.drafts)
self.mailboxes.trash = mock()
self.mailboxes.sent = mock()
self.mail_sender = mock()
self.search_engine = mock()
self.mail_service = MailService(self.mailboxes, self.mail_sender,
self.mail_store, self.querier,
self.search_engine)
def tearDown(self):
unstub()
def test_send_mail(self):
when(InputMail).from_dict(ANY()).thenReturn('inputmail')
when(self.mail_sender).sendmail(ANY()).thenReturn(defer.Deferred())
sent_deferred = self.mail_service.send_mail(mail_dict())
verify(self.mail_sender).sendmail("inputmail")
sent_deferred.callback('Assume sending mail succeeded')
return sent_deferred
@defer.inlineCallbacks
def test_send_mail_removes_draft(self):
mail = mock()
when(mail).raw = 'raw mail'
when(InputMail).from_dict(ANY()).thenReturn(mail)
when(self.mail_store).delete_mail('12').thenReturn(defer.succeed(None))
when(self.mail_store).add_mail('SENT',
ANY()).thenReturn(defer.succeed(None))
deferred_success = defer.succeed(None)
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_success)
yield self.mail_service.send_mail({'ident': '12'})
verify(self.mail_sender).sendmail(mail)
verify(self.mail_store).add_mail('SENT', 'raw mail')
verify(self.mail_store).delete_mail('12')
@defer.inlineCallbacks
def test_send_mail_does_not_delete_draft_on_error(self):
when(InputMail).from_dict(ANY()).thenReturn('inputmail')
deferred_failure = defer.fail(Exception("Assume sending mail failed"))
when(self.mail_sender).sendmail(ANY()).thenReturn(deferred_failure)
try:
yield self.mail_service.send_mail({'ident': '12'})
self.fail(
"send_mail is expected to raise if underlying call fails")
except:
verify(self.mail_sender).sendmail("inputmail")
verifyNoMoreInteractions(self.drafts)
@defer.inlineCallbacks
def test_mark_as_read(self):
mail = LeapMail('id', 'INBOX')
when(self.mail_store).get_mail(ANY(),
include_body=True).thenReturn(mail)
yield self.mail_service.mark_as_read(1)
self.assertIn(Status.SEEN, mail.flags)
verify(self.mail_store).update_mail(mail)
@defer.inlineCallbacks
def test_delete_mail(self):
mail_to_delete = LeapMail(1, 'INBOX')
when(self.mail_store).get_mail(1, include_body=True).thenReturn(
defer.succeed(mail_to_delete))
yield self.mail_service.delete_mail(1)
verify(self.mail_store).move_mail_to_mailbox(1, 'TRASH')
def test_recover_mail(self):
mail_to_recover = PixelatedMail.from_soledad(*leap_mail(),
soledad_querier=None)
when(self.mail_service).mail(1).thenReturn(mail_to_recover)
when(self.mailboxes).move_to_inbox(1).thenReturn(mail_to_recover)
self.mail_service.recover_mail(1)
verify(self.mailboxes).move_to_inbox(1)
verify(self.search_engine).index_mail(mail_to_recover)
