git.ozlabs.org Git - patchwork/blob - patchwork/tests/test_patchparser.py

   1 # Patchwork - automated patch tracking system
   2 # Copyright (C) 2008 Jeremy Kerr <jk@ozlabs.org>
   3 #
   4 # This file is part of the Patchwork package.
   5 #
   6 # Patchwork is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # Patchwork is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with Patchwork; if not, write to the Free Software
  18 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19
  20 import os
  21 from email import message_from_string
  22 from django.test import TestCase
  23 from patchwork.models import Project, Person, Patch, Comment, State, \
  24          get_default_initial_patch_state
  25 from patchwork.tests.utils import read_patch, read_mail, create_email, \
  26          defaults, create_user
  27
  28 try:
  29     from email.mime.text import MIMEText
  30 except ImportError:
  31     # Python 2.4 compatibility
  32     from email.MIMEText import MIMEText
  33
  34 class PatchTest(TestCase):
  35     default_sender = defaults.sender
  36     default_subject = defaults.subject
  37     project = defaults.project
  38
  39 from patchwork.bin.parsemail import find_content, find_author, find_project, \
  40                                     parse_mail
  41
  42 class InlinePatchTest(PatchTest):
  43     patch_filename = '0001-add-line.patch'
  44     test_comment = 'Test for attached patch'
  45
  46     def setUp(self):
  47         self.orig_patch = read_patch(self.patch_filename)
  48         email = create_email(self.test_comment + '\n' + self.orig_patch)
  49         (self.patch, self.comment) = find_content(self.project, email)
  50
  51     def testPatchPresence(self):
  52         self.assertTrue(self.patch is not None)
  53
  54     def testPatchContent(self):
  55         self.assertEquals(self.patch.content, self.orig_patch)
  56
  57     def testCommentPresence(self):
  58         self.assertTrue(self.comment is not None)
  59
  60     def testCommentContent(self):
  61         self.assertEquals(self.comment.content, self.test_comment)
  62
  63
  64 class AttachmentPatchTest(InlinePatchTest):
  65     patch_filename = '0001-add-line.patch'
  66     test_comment = 'Test for attached patch'
  67     content_subtype = 'x-patch'
  68
  69     def setUp(self):
  70         self.orig_patch = read_patch(self.patch_filename)
  71         email = create_email(self.test_comment, multipart = True)
  72         attachment = MIMEText(self.orig_patch, _subtype = self.content_subtype)
  73         email.attach(attachment)
  74         (self.patch, self.comment) = find_content(self.project, email)
  75
  76 class AttachmentXDiffPatchTest(AttachmentPatchTest):
  77     content_subtype = 'x-diff'
  78
  79 class UTF8InlinePatchTest(InlinePatchTest):
  80     patch_filename = '0002-utf-8.patch'
  81     patch_encoding = 'utf-8'
  82
  83     def setUp(self):
  84         self.orig_patch = read_patch(self.patch_filename, self.patch_encoding)
  85         email = create_email(self.test_comment + '\n' + self.orig_patch,
  86                              content_encoding = self.patch_encoding)
  87         (self.patch, self.comment) = find_content(self.project, email)
  88
  89 class NoCharsetInlinePatchTest(InlinePatchTest):
  90     """ Test mails with no content-type or content-encoding header """
  91     patch_filename = '0001-add-line.patch'
  92
  93     def setUp(self):
  94         self.orig_patch = read_patch(self.patch_filename)
  95         email = create_email(self.test_comment + '\n' + self.orig_patch)
  96         del email['Content-Type']
  97         del email['Content-Transfer-Encoding']
  98         (self.patch, self.comment) = find_content(self.project, email)
  99
 100 class SignatureCommentTest(InlinePatchTest):
 101     patch_filename = '0001-add-line.patch'
 102     test_comment = 'Test comment\nmore comment'
 103
 104     def setUp(self):
 105         self.orig_patch = read_patch(self.patch_filename)
 106         email = create_email( \
 107                 self.test_comment + '\n' + \
 108                 '-- \nsig\n' + self.orig_patch)
 109         (self.patch, self.comment) = find_content(self.project, email)
 110
 111
 112 class ListFooterTest(InlinePatchTest):
 113     patch_filename = '0001-add-line.patch'
 114     test_comment = 'Test comment\nmore comment'
 115
 116     def setUp(self):
 117         self.orig_patch = read_patch(self.patch_filename)
 118         email = create_email( \
 119                 self.test_comment + '\n' + \
 120                 '_______________________________________________\n' + \
 121                 'Linuxppc-dev mailing list\n' + \
 122                 self.orig_patch)
 123         (self.patch, self.comment) = find_content(self.project, email)
 124
 125
 126 class DiffWordInCommentTest(InlinePatchTest):
 127     test_comment = 'Lines can start with words beginning in "diff"\n' + \
 128                    'difficult\nDifferent'
 129
 130
 131 class UpdateCommentTest(InlinePatchTest):
 132     """ Test for '---\nUpdate: v2' style comments to patches. """
 133     patch_filename = '0001-add-line.patch'
 134     test_comment = 'Test comment\nmore comment\n---\nUpdate: test update'
 135
 136 class UpdateSigCommentTest(SignatureCommentTest):
 137     """ Test for '---\nUpdate: v2' style comments to patches, with a sig """
 138     patch_filename = '0001-add-line.patch'
 139     test_comment = 'Test comment\nmore comment\n---\nUpdate: test update'
 140
 141 class SenderEncodingTest(TestCase):
 142     sender_name = u'example user'
 143     sender_email = 'user@example.com'
 144     from_header = 'example user <user@example.com>'
 145
 146     def setUp(self):
 147         mail = 'From: %s\n' % self.from_header + \
 148                'Subject: test\n\n' + \
 149                'test'
 150         self.email = message_from_string(mail)
 151         (self.person, new) = find_author(self.email)
 152         self.person.save()
 153
 154     def tearDown(self):
 155         self.person.delete()
 156
 157     def testName(self):
 158         self.assertEquals(self.person.name, self.sender_name)
 159
 160     def testEmail(self):
 161         self.assertEquals(self.person.email, self.sender_email)
 162
 163     def testDBQueryName(self):
 164         db_person = Person.objects.get(name = self.sender_name)
 165         self.assertEquals(self.person, db_person)
 166
 167     def testDBQueryEmail(self):
 168         db_person = Person.objects.get(email = self.sender_email)
 169         self.assertEquals(self.person, db_person)
 170
 171
 172 class SenderUTF8QPEncodingTest(SenderEncodingTest):
 173     sender_name = u'\xe9xample user'
 174     from_header = '=?utf-8?q?=C3=A9xample=20user?= <user@example.com>'
 175
 176 class SenderUTF8QPSplitEncodingTest(SenderEncodingTest):
 177     sender_name = u'\xe9xample user'
 178     from_header = '=?utf-8?q?=C3=A9xample?= user <user@example.com>'
 179
 180 class SenderUTF8B64EncodingTest(SenderUTF8QPEncodingTest):
 181     from_header = '=?utf-8?B?w6l4YW1wbGUgdXNlcg==?= <user@example.com>'
 182
 183 class SubjectEncodingTest(PatchTest):
 184     sender = 'example user <user@example.com>'
 185     subject = 'test subject'
 186     subject_header = 'test subject'
 187
 188     def setUp(self):
 189         mail = 'From: %s\n' % self.sender + \
 190                'Subject: %s\n\n' % self.subject_header + \
 191                'test\n\n' + defaults.patch
 192         self.projects = defaults.project
 193         self.email = message_from_string(mail)
 194
 195     def testSubjectEncoding(self):
 196         (patch, comment) = find_content(self.project, self.email)
 197         self.assertEquals(patch.name, self.subject)
 198
 199 class SubjectUTF8QPEncodingTest(SubjectEncodingTest):
 200     subject = u'test s\xfcbject'
 201     subject_header = '=?utf-8?q?test=20s=c3=bcbject?='
 202
 203 class SubjectUTF8QPMultipleEncodingTest(SubjectEncodingTest):
 204     subject = u'test s\xfcbject'
 205     subject_header = 'test =?utf-8?q?s=c3=bcbject?='
 206
 207 class SenderCorrelationTest(TestCase):
 208     existing_sender = 'Existing Sender <existing@example.com>'
 209     non_existing_sender = 'Non-existing Sender <nonexisting@example.com>'
 210
 211     def mail(self, sender):
 212         return message_from_string('From: %s\nSubject: Test\n\ntest\n' % sender)
 213
 214     def setUp(self):
 215         self.existing_sender_mail = self.mail(self.existing_sender)
 216         self.non_existing_sender_mail = self.mail(self.non_existing_sender)
 217         (self.person, new) = find_author(self.existing_sender_mail)
 218         self.person.save()
 219
 220     def testExisingSender(self):
 221         (person, new) = find_author(self.existing_sender_mail)
 222         self.assertEqual(new, False)
 223         self.assertEqual(person.id, self.person.id)
 224
 225     def testNonExisingSender(self):
 226         (person, new) = find_author(self.non_existing_sender_mail)
 227         self.assertEqual(new, True)
 228         self.assertEqual(person.id, None)
 229
 230     def testExistingDifferentFormat(self):
 231         mail = self.mail('existing@example.com')
 232         (person, new) = find_author(mail)
 233         self.assertEqual(new, False)
 234         self.assertEqual(person.id, self.person.id)
 235
 236     def testExistingDifferentCase(self):
 237         mail = self.mail(self.existing_sender.upper())
 238         (person, new) = find_author(mail)
 239         self.assertEqual(new, False)
 240         self.assertEqual(person.id, self.person.id)
 241
 242     def tearDown(self):
 243         self.person.delete()
 244
 245 class MultipleProjectPatchTest(TestCase):
 246     """ Test that patches sent to multiple patchwork projects are
 247         handled correctly """
 248
 249     test_comment = 'Test Comment'
 250     patch_filename = '0001-add-line.patch'
 251     msgid = '<1@example.com>'
 252
 253     def setUp(self):
 254         self.p1 = Project(linkname = 'test-project-1', name = 'Project 1',
 255                 listid = '1.example.com', listemail='1@example.com')
 256         self.p2 = Project(linkname = 'test-project-2', name = 'Project 2',
 257                 listid = '2.example.com', listemail='2@example.com')
 258
 259         self.p1.save()
 260         self.p2.save()
 261
 262         patch = read_patch(self.patch_filename)
 263         email = create_email(self.test_comment + '\n' + patch)
 264         email['Message-Id'] = self.msgid
 265
 266         del email['List-ID']
 267         email['List-ID'] = '<' + self.p1.listid + '>'
 268         parse_mail(email)
 269
 270         del email['List-ID']
 271         email['List-ID'] = '<' + self.p2.listid + '>'
 272         parse_mail(email)
 273
 274     def testParsedProjects(self):
 275         self.assertEquals(Patch.objects.filter(project = self.p1).count(), 1)
 276         self.assertEquals(Patch.objects.filter(project = self.p2).count(), 1)
 277
 278     def tearDown(self):
 279         self.p1.delete()
 280         self.p2.delete()
 281
 282
 283 class MultipleProjectPatchCommentTest(MultipleProjectPatchTest):
 284     """ Test that followups to multiple-project patches end up on the
 285         correct patch """
 286
 287     comment_msgid = '<2@example.com>'
 288     comment_content = 'test comment'
 289
 290     def setUp(self):
 291         super(MultipleProjectPatchCommentTest, self).setUp()
 292
 293         for project in [self.p1, self.p2]:
 294             email = MIMEText(self.comment_content)
 295             email['From'] = defaults.sender
 296             email['Subject'] = defaults.subject
 297             email['Message-Id'] = self.comment_msgid
 298             email['List-ID'] = '<' + project.listid + '>'
 299             email['In-Reply-To'] = self.msgid
 300             parse_mail(email)
 301
 302     def testParsedComment(self):
 303         for project in [self.p1, self.p2]:
 304             patch = Patch.objects.filter(project = project)[0]
 305             # we should see two comments now - the original mail with the patch,
 306             # and the one we parsed in setUp()
 307             self.assertEquals(Comment.objects.filter(patch = patch).count(), 2)
 308
 309 class ListIdHeaderTest(TestCase):
 310     """ Test that we parse List-Id headers from mails correctly """
 311     def setUp(self):
 312         self.project = Project(linkname = 'test-project-1', name = 'Project 1',
 313                 listid = '1.example.com', listemail='1@example.com')
 314         self.project.save()
 315
 316     def testNoListId(self):
 317         email = MIMEText('')
 318         project = find_project(email)
 319         self.assertEquals(project, None)
 320
 321     def testBlankListId(self):
 322         email = MIMEText('')
 323         email['List-Id'] = ''
 324         project = find_project(email)
 325         self.assertEquals(project, None)
 326
 327     def testWhitespaceListId(self):
 328         email = MIMEText('')
 329         email['List-Id'] = ' '
 330         project = find_project(email)
 331         self.assertEquals(project, None)
 332
 333     def testSubstringListId(self):
 334         email = MIMEText('')
 335         email['List-Id'] = 'example.com'
 336         project = find_project(email)
 337         self.assertEquals(project, None)
 338
 339     def testShortListId(self):
 340         """ Some mailing lists have List-Id headers in short formats, where it
 341             is only the list ID itself (without enclosing angle-brackets). """
 342         email = MIMEText('')
 343         email['List-Id'] = self.project.listid
 344         project = find_project(email)
 345         self.assertEquals(project, self.project)
 346
 347     def testLongListId(self):
 348         email = MIMEText('')
 349         email['List-Id'] = 'Test text <%s>' % self.project.listid
 350         project = find_project(email)
 351         self.assertEquals(project, self.project)
 352
 353     def tearDown(self):
 354         self.project.delete()
 355
 356 class MBoxPatchTest(PatchTest):
 357     def setUp(self):
 358         self.mail = read_mail(self.mail_file, project = self.project)
 359
 360 class GitPullTest(MBoxPatchTest):
 361     mail_file = '0001-git-pull-request.mbox'
 362
 363     def testGitPullRequest(self):
 364         (patch, comment) = find_content(self.project, self.mail)
 365         self.assertTrue(patch is not None)
 366         self.assertTrue(patch.pull_url is not None)
 367         self.assertTrue(patch.content is None)
 368         self.assertTrue(comment is not None)
 369
 370 class GitPullWrappedTest(GitPullTest):
 371     mail_file = '0002-git-pull-request-wrapped.mbox'
 372
 373 class GitPullWithDiffTest(MBoxPatchTest):
 374     mail_file = '0003-git-pull-request-with-diff.mbox'
 375
 376     def testGitPullWithDiff(self):
 377         (patch, comment) = find_content(self.project, self.mail)
 378         self.assertTrue(patch is not None)
 379         self.assertEqual('git://git.kernel.org/pub/scm/linux/kernel/git/tip/' +
 380              'linux-2.6-tip.git x86-fixes-for-linus', patch.pull_url)
 381         self.assertTrue(
 382             patch.content.startswith('diff --git a/arch/x86/include/asm/smp.h'),
 383             patch.content)
 384         self.assertTrue(comment is not None)
 385
 386 class GitPullGitSSHUrlTest(GitPullTest):
 387     mail_file = '0004-git-pull-request-git+ssh.mbox'
 388
 389 class GitPullSSHUrlTest(GitPullTest):
 390     mail_file = '0005-git-pull-request-ssh.mbox'
 391
 392 class GitPullHTTPUrlTest(GitPullTest):
 393     mail_file = '0006-git-pull-request-http.mbox'
 394
 395 class GitRenameOnlyTest(MBoxPatchTest):
 396     mail_file = '0008-git-rename.mbox'
 397
 398     def testGitRename(self):
 399         (patch, comment) = find_content(self.project, self.mail)
 400         self.assertTrue(patch is not None)
 401         self.assertTrue(comment is not None)
 402         self.assertEqual(patch.content.count("\nrename from "), 2)
 403         self.assertEqual(patch.content.count("\nrename to "), 2)
 404
 405 class GitRenameWithDiffTest(MBoxPatchTest):
 406     mail_file = '0009-git-rename-with-diff.mbox'
 407
 408     def testGitRename(self):
 409         (patch, comment) = find_content(self.project, self.mail)
 410         self.assertTrue(patch is not None)
 411         self.assertTrue(comment is not None)
 412         self.assertEqual(patch.content.count("\nrename from "), 2)
 413         self.assertEqual(patch.content.count("\nrename to "), 2)
 414         self.assertEqual(patch.content.count('\n-a\n+b'), 1)
 415
 416 class CVSFormatPatchTest(MBoxPatchTest):
 417     mail_file = '0007-cvs-format-diff.mbox'
 418
 419     def testPatch(self):
 420         (patch, comment) = find_content(self.project, self.mail)
 421         self.assertTrue(patch is not None)
 422         self.assertTrue(comment is not None)
 423         self.assertTrue(patch.content.startswith('Index'))
 424
 425 class CharsetFallbackPatchTest(MBoxPatchTest):
 426     """ Test mail with and invalid charset name, and check that we can parse
 427         with one of the fallback encodings"""
 428
 429     mail_file = '0010-invalid-charset.mbox'
 430
 431     def testPatch(self):
 432         (patch, comment) = find_content(self.project, self.mail)
 433         self.assertTrue(patch is not None)
 434         self.assertTrue(comment is not None)
 435
 436 class NoNewlineAtEndOfFilePatchTest(MBoxPatchTest):
 437     mail_file = '0011-no-newline-at-end-of-file.mbox'
 438
 439     def testPatch(self):
 440         (patch, comment) = find_content(self.project, self.mail)
 441         self.assertTrue(patch is not None)
 442         self.assertTrue(comment is not None)
 443         self.assertTrue(patch.content.startswith('diff --git a/tools/testing/selftests/powerpc/Makefile'))
 444         # Confirm the trailing no newline marker doesn't end up in the comment
 445         self.assertFalse(comment.content.rstrip().endswith('\ No newline at end of file'))
 446         # Confirm it's instead at the bottom of the patch
 447         self.assertTrue(patch.content.rstrip().endswith('\ No newline at end of file'))
 448         # Confirm we got both markers
 449         self.assertEqual(2, patch.content.count('\ No newline at end of file'))
 450
 451 class DelegateRequestTest(TestCase):
 452     patch_filename = '0001-add-line.patch'
 453     msgid = '<1@example.com>'
 454     invalid_delegate_email = "nobody"
 455
 456     def setUp(self):
 457         self.patch = read_patch(self.patch_filename)
 458         self.user = create_user()
 459         self.p1 = Project(linkname = 'test-project-1', name = 'Project 1',
 460                 listid = '1.example.com', listemail='1@example.com')
 461         self.p1.save()
 462
 463     def get_email(self):
 464         email = create_email(self.patch)
 465         del email['List-ID']
 466         email['List-ID'] = '<' + self.p1.listid + '>'
 467         email['Message-Id'] = self.msgid
 468         return email
 469
 470     def _assertDelegate(self, delegate):
 471         query = Patch.objects.filter(project=self.p1)
 472         self.assertEquals(query.count(), 1)
 473         self.assertEquals(query[0].delegate, delegate)
 474
 475     def testDelegate(self):
 476         email = self.get_email()
 477         email['X-Patchwork-Delegate'] = self.user.email
 478         parse_mail(email)
 479         self._assertDelegate(self.user)
 480
 481     def testNoDelegate(self):
 482         email = self.get_email()
 483         parse_mail(email)
 484         self._assertDelegate(None)
 485
 486     def testInvalidDelegateFallsBackToNoDelegate(self):
 487         email = self.get_email()
 488         email['X-Patchwork-Delegate'] = self.invalid_delegate_email
 489         parse_mail(email)
 490         self._assertDelegate(None)
 491
 492     def tearDown(self):
 493         self.p1.delete()
 494         self.user.delete()
 495
 496 class InitialPatchStateTest(TestCase):
 497     patch_filename = '0001-add-line.patch'
 498     msgid = '<1@example.com>'
 499     invalid_state_name = "Nonexistent Test State"
 500
 501     def setUp(self):
 502         self.patch = read_patch(self.patch_filename)
 503         self.user = create_user()
 504         self.p1 = Project(linkname = 'test-project-1', name = 'Project 1',
 505                 listid = '1.example.com', listemail='1@example.com')
 506         self.p1.save()
 507         self.default_state = get_default_initial_patch_state()
 508         self.nondefault_state = State.objects.get(name="Accepted")
 509
 510     def get_email(self):
 511         email = create_email(self.patch)
 512         del email['List-ID']
 513         email['List-ID'] = '<' + self.p1.listid + '>'
 514         email['Message-Id'] = self.msgid
 515         return email
 516
 517     def _assertState(self, state):
 518         query = Patch.objects.filter(project=self.p1)
 519         self.assertEquals(query.count(), 1)
 520         self.assertEquals(query[0].state, state)
 521
 522     def testNonDefaultStateIsActuallyNotTheDefaultState(self):
 523         self.assertNotEqual(self.default_state, self.nondefault_state)
 524
 525     def testExplicitNonDefaultStateRequest(self):
 526         email = self.get_email()
 527         email['X-Patchwork-State'] = self.nondefault_state.name
 528         parse_mail(email)
 529         self._assertState(self.nondefault_state)
 530
 531     def testExplicitDefaultStateRequest(self):
 532         email = self.get_email()
 533         email['X-Patchwork-State'] = self.default_state.name
 534         parse_mail(email)
 535         self._assertState(self.default_state)
 536
 537     def testImplicitDefaultStateRequest(self):
 538         email = self.get_email()
 539         parse_mail(email)
 540         self._assertState(self.default_state)
 541
 542     def testInvalidTestStateDoesNotExist(self):
 543         with self.assertRaises(State.DoesNotExist):
 544             State.objects.get(name=self.invalid_state_name)
 545
 546     def testInvalidStateRequestFallsBackToDefaultState(self):
 547         email = self.get_email()
 548         email['X-Patchwork-State'] = self.invalid_state_name
 549         parse_mail(email)
 550         self._assertState(self.default_state)
 551
 552     def tearDown(self):
 553         self.p1.delete()
 554         self.user.delete()
 555
 556 class ParseInitialTagsTest(PatchTest):
 557     patch_filename = '0001-add-line.patch'
 558     test_comment = ('test comment\n\n' +
 559         'Tested-by: Test User <test@example.com>\n' +
 560         'Reviewed-by: Test User <test@example.com>\n')
 561     fixtures = ['default_tags']
 562
 563     def setUp(self):
 564         project = defaults.project
 565         project.listid = 'test.example.com'
 566         project.save()
 567         self.orig_patch = read_patch(self.patch_filename)
 568         email = create_email(self.test_comment + '\n' + self.orig_patch,
 569                              project = project)
 570         email['Message-Id'] = '<1@example.com>'
 571         parse_mail(email)
 572
 573     def testTags(self):
 574         self.assertEquals(Patch.objects.count(), 1)
 575         patch = Patch.objects.all()[0]
 576         self.assertEquals(patch.patchtag_set.filter(
 577                             tag__name='Acked-by').count(), 0)
 578         self.assertEquals(patch.patchtag_set.get(
 579                             tag__name='Reviewed-by').count, 1)
 580         self.assertEquals(patch.patchtag_set.get(
 581                             tag__name='Tested-by').count, 1)