def test_fromEmail_always_creates(self):
"""Even when messages are identical, fromEmail creates a new one."""
email = self.factory.makeEmailMessage()
orig_message = MessageSet().fromEmail(email.as_string())
transaction.commit()
dupe_message = MessageSet().fromEmail(email.as_string())
self.assertNotEqual(orig_message.id, dupe_message.id)
def test_flattenThreads(self):
"""Test MessageSet.flattenThreads."""
messages = self.createTestMessages()
message1, message2, message3, message4 = messages
threads = MessageSet.threadMessages(messages)
flattened = list(MessageSet.flattenThreads(threads))
expected = [(0, message1), (1, message2), (2, message4), (1, message3)]
self.assertEqual(expected, flattened)
def test_flattenThreads(self):
"""Test MessageSet.flattenThreads."""
messages = self.createTestMessages()
message1, message2, message3, message4 = messages
threads = MessageSet.threadMessages(messages)
flattened = list(MessageSet.flattenThreads(threads))
expected = [(0, message1), (1, message2), (2, message4), (1, message3)]
self.assertEqual(expected, flattened)
def test_fromEmail_restricted_attachments(self):
"""fromEmail creates restricted attachments correctly."""
msg = self._makeMessageWithAttachment()
message = MessageSet().fromEmail(msg.as_string(), restricted=True)
text, diff = message.chunks
self.assertEqual('review.diff', diff.blob.filename)
self.assertTrue('review.diff', diff.blob.restricted)
def test_fromEmail_decodes_macintosh_encoding(self):
""""macintosh encoding is equivalent to MacRoman."""
high_decoded = self.high_characters.decode('macroman')
email = self.makeEncodedEmail('macintosh', 'macroman')
message = MessageSet().fromEmail(email.as_string())
self.assertEqual(high_decoded, message.subject)
self.assertEqual(high_decoded, message.text_contents)
def test_fromEmail_decodes_booga_encoding(self):
""""'booga' encoding is decoded as latin-1."""
high_decoded = self.high_characters.decode('latin-1')
email = self.makeEncodedEmail('booga', 'latin-1')
message = MessageSet().fromEmail(email.as_string())
self.assertEqual(high_decoded, message.subject)
self.assertEqual(high_decoded, message.text_contents)
def test_threadMessages(self):
"""Test MessageSet.threadMessages."""
messages = self.createTestMessages()
message1, message2, message3, message4 = messages
threads = MessageSet.threadMessages(messages)
self.assertEqual([(message1, [(message2, [(message4, [])]),
(message3, [])])], threads)
def test_threadMessages(self):
"""Test MessageSet.threadMessages."""
messages = self.createTestMessages()
message1, message2, message3, message4 = messages
threads = MessageSet.threadMessages(messages)
self.assertEqual(
[(message1, [(message2, [(message4, [])]), (message3, [])])],
threads)
def _makeCommentFromEmailWithAttachment(self, filename, content_type):
# Make an email message with an attachment, and create a code
# review comment from it.
msg = self.factory.makeEmailMessage(
body='This is the body of the email.',
attachments=[
(filename, content_type, 'Attachment body')])
message = MessageSet().fromEmail(msg.as_string())
return self.bmp.createCommentFromMessage(message, None, None, msg)
def test_oops_in_messagechunk(self):
oopsid = "OOPS-abcdef1234"
MessageSet().fromText('foo', "foo %s bar" % oopsid)
self.store.flush()
now = datetime.now(tz=utc)
day = timedelta(days=1)
self.failUnlessEqual(set([oopsid]),
referenced_oops(now - day, now, "product=1", {}))
self.failUnlessEqual(
set(), referenced_oops(now + day, now + day, "product=1", {}))
def test_process(self):
"""Processing an email creates an appropriate CodeReviewComment."""
mail = self.factory.makeSignedMessage('<my-id>')
bmp = self.factory.makeBranchMergeProposal()
email_addr = bmp.address
switch_dbuser(config.processmail.dbuser)
self.assertTrue(self.code_handler.process(
mail, email_addr, None), "Succeeded, but didn't return True")
# if the message has not been created, this raises SQLObjectNotFound
MessageSet().get('<my-id>')
def test_fromEmail_restricted_reuploads(self):
"""fromEmail will re-upload the email to the restricted librarian if
restricted is True."""
filealias = self.factory.makeLibraryFileAlias()
transaction.commit()
email = self.factory.makeEmailMessage()
message = MessageSet().fromEmail(email.as_string(),
filealias=filealias,
restricted=True)
self.assertTrue(message.raw.restricted)
self.assertNotEqual(message.raw.id, filealias.id)
def test_parentToChild(self):
"""Test MessageSet._parentToChild."""
messages = self.createTestMessages()
message1, message2, message3, message4 = messages
expected = {
message1: [message2, message3],
message2: [message4],
message3: [], message4: []}
result, roots = MessageSet._parentToChild(messages)
self.assertEqual(expected, result)
self.assertEqual([message1], roots)
def test_oops_in_messagesubject(self):
oopsid = "OOPS-abcdef1234"
self.factory.makeEmailMessage()
MessageSet().fromText("Crash with %s" % oopsid, "body")
self.store.flush()
now = datetime.now(tz=utc)
day = timedelta(days=1)
self.failUnlessEqual(set([oopsid]),
referenced_oops(now - day, now, "product=1", {}))
self.failUnlessEqual(
set(), referenced_oops(now + day, now + day, "product=1", {}))
def test_fromEmail_strips_attachment_paths(self):
# Build a simple multipart message with a plain text first part
# and an text/x-diff attachment.
msg = self._makeMessageWithAttachment(filename='/tmp/foo/review.diff')
# Now create the message from the MessageSet.
message = MessageSet().fromEmail(msg.as_string())
text, diff = message.chunks
self.assertEqual('This is the body of the email.', text.content)
self.assertEqual('review.diff', diff.blob.filename)
self.assertEqual('text/x-diff', diff.blob.mimetype)
# Need to commit in order to read back out of the librarian.
transaction.commit()
self.assertEqual('This is the diff, honest.', diff.blob.read())
def test_parentToChild(self):
"""Test MessageSet._parentToChild."""
messages = self.createTestMessages()
message1, message2, message3, message4 = messages
expected = {
message1: [message2, message3],
message2: [message4],
message3: [],
message4: []
}
result, roots = MessageSet._parentToChild(messages)
self.assertEqual(expected, result)
self.assertEqual([message1], roots)
def test_addNotification_without_recipients(self):
# We can call BugNotificationSet.addNotification() with a empty
# recipient list.
#
# No explicit assertion is necessary in this test -- we just want
# to be sure that calling BugNotificationSet.addNotification()
# does not lead to an exception caused by an SQL syntax error for
# a command that ends with "VALUES ;"
bug = self.factory.makeBug()
message = MessageSet().fromText(subject='subject', content='content')
BugNotificationSet().addNotification(bug=bug,
is_comment=False,
message=message,
recipients=[],
activity=None)
def test_decode_utf8(self):
"""Test decode with a known encoding."""
result = MessageSet.decode(u'\u1234'.encode('utf-8'), 'utf-8')
self.assertEqual(u'\u1234', result)
def test_decode_unknown_ascii(self):
"""Test decode with ascii characters in an unknown encoding."""
result = MessageSet.decode('abcde', 'booga')
self.assertEqual(u'abcde', result)
def test_decode_unknown_high_characters(self):
"""Test decode with non-ascii characters in an unknown encoding."""
with self.expectedLog('Treating unknown encoding "booga" as latin-1.'):
result = MessageSet.decode(self.high_characters, 'booga')
self.assertEqual(self.high_characters.decode('latin-1'), result)
def test_decode_unknown_ascii(self):
"""Test decode with ascii characters in an unknown encoding."""
result = MessageSet.decode('abcde', 'booga')
self.assertEqual(u'abcde', result)
def test_decode_macintosh(self):
"""Test decode with macintosh encoding."""
result = MessageSet.decode(self.high_characters, 'macintosh')
self.assertEqual(self.high_characters.decode('macroman'), result)
def test_decode_utf8(self):
"""Test decode with a known encoding."""
result = MessageSet.decode(u'\u1234'.encode('utf-8'), 'utf-8')
self.assertEqual(u'\u1234', result)
def test_decode_unknown_high_characters(self):
"""Test decode with non-ascii characters in an unknown encoding."""
with self.expectedLog(
'Treating unknown encoding "booga" as latin-1.'):
result = MessageSet.decode(self.high_characters, 'booga')
self.assertEqual(self.high_characters.decode('latin-1'), result)
def test_decode_macintosh(self):
"""Test decode with macintosh encoding."""
result = MessageSet.decode(self.high_characters, 'macintosh')
self.assertEqual(self.high_characters.decode('macroman'), result)
