git.ozlabs.org Git - patchwork/blob - apps/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 DelegateRequestTest(TestCase):
 426     patch_filename = '0001-add-line.patch'
 427     msgid = '<1@example.com>'
 428     invalid_delegate_email = "nobody"
 429
 430     def setUp(self):
 431         self.patch = read_patch(self.patch_filename)
 432         self.user = create_user()
 433         self.p1 = Project(linkname = 'test-project-1', name = 'Project 1',
 434                 listid = '1.example.com', listemail='1@example.com')
 435         self.p1.save()
 436
 437     def get_email(self):
 438         email = create_email(self.patch)
 439         del email['List-ID']
 440         email['List-ID'] = '<' + self.p1.listid + '>'
 441         email['Message-Id'] = self.msgid
 442         return email
 443
 444     def _assertDelegate(self, delegate):
 445         query = Patch.objects.filter(project=self.p1)
 446         self.assertEquals(query.count(), 1)
 447         self.assertEquals(query[0].delegate, delegate)
 448
 449     def testDelegate(self):
 450         email = self.get_email()
 451         email['X-Patchwork-Delegate'] = self.user.email
 452         parse_mail(email)
 453         self._assertDelegate(self.user)
 454
 455     def testNoDelegate(self):
 456         email = self.get_email()
 457         parse_mail(email)
 458         self._assertDelegate(None)
 459
 460     def testInvalidDelegateFallsBackToNoDelegate(self):
 461         email = self.get_email()
 462         email['X-Patchwork-Delegate'] = self.invalid_delegate_email
 463         parse_mail(email)
 464         self._assertDelegate(None)
 465
 466     def tearDown(self):
 467         self.p1.delete()
 468         self.user.delete()
 469
 470 class InitialPatchStateTest(TestCase):
 471     patch_filename = '0001-add-line.patch'
 472     msgid = '<1@example.com>'
 473     invalid_state_name = "Nonexistent Test State"
 474
 475     def setUp(self):
 476         self.patch = read_patch(self.patch_filename)
 477         self.user = create_user()
 478         self.p1 = Project(linkname = 'test-project-1', name = 'Project 1',
 479                 listid = '1.example.com', listemail='1@example.com')
 480         self.p1.save()
 481         self.default_state = get_default_initial_patch_state()
 482         self.nondefault_state = State.objects.get(name="Accepted")
 483
 484     def get_email(self):
 485         email = create_email(self.patch)
 486         del email['List-ID']
 487         email['List-ID'] = '<' + self.p1.listid + '>'
 488         email['Message-Id'] = self.msgid
 489         return email
 490
 491     def _assertState(self, state):
 492         query = Patch.objects.filter(project=self.p1)
 493         self.assertEquals(query.count(), 1)
 494         self.assertEquals(query[0].state, state)
 495
 496     def testNonDefaultStateIsActuallyNotTheDefaultState(self):
 497         self.assertNotEqual(self.default_state, self.nondefault_state)
 498
 499     def testExplicitNonDefaultStateRequest(self):
 500         email = self.get_email()
 501         email['X-Patchwork-State'] = self.nondefault_state.name
 502         parse_mail(email)
 503         self._assertState(self.nondefault_state)
 504
 505     def testExplicitDefaultStateRequest(self):
 506         email = self.get_email()
 507         email['X-Patchwork-State'] = self.default_state.name
 508         parse_mail(email)
 509         self._assertState(self.default_state)
 510
 511     def testImplicitDefaultStateRequest(self):
 512         email = self.get_email()
 513         parse_mail(email)
 514         self._assertState(self.default_state)
 515
 516     def testInvalidTestStateDoesNotExist(self):
 517         with self.assertRaises(State.DoesNotExist):
 518             State.objects.get(name=self.invalid_state_name)
 519
 520     def testInvalidStateRequestFallsBackToDefaultState(self):
 521         email = self.get_email()
 522         email['X-Patchwork-State'] = self.invalid_state_name
 523         parse_mail(email)
 524         self._assertState(self.default_state)
 525
 526     def tearDown(self):
 527         self.p1.delete()
 528         self.user.delete()