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 from email.mime.text import MIMEText
  29
  30 class PatchTest(TestCase):
  31     fixtures = ['default_states']
  32     default_sender = defaults.sender
  33     default_subject = defaults.subject
  34     project = defaults.project
  35
  36 from patchwork.bin.parsemail import find_content, find_author, find_project, \
  37                                     parse_mail, split_prefixes, clean_subject
  38
  39 class InlinePatchTest(PatchTest):
  40     patch_filename = '0001-add-line.patch'
  41     test_comment = 'Test for attached patch'
  42
  43     def setUp(self):
  44         self.orig_patch = read_patch(self.patch_filename)
  45         email = create_email(self.test_comment + '\n' + self.orig_patch)
  46         (self.patch, self.comment) = find_content(self.project, email)
  47
  48     def testPatchPresence(self):
  49         self.assertTrue(self.patch is not None)
  50
  51     def testPatchContent(self):
  52         self.assertEquals(self.patch.content, self.orig_patch)
  53
  54     def testCommentPresence(self):
  55         self.assertTrue(self.comment is not None)
  56
  57     def testCommentContent(self):
  58         self.assertEquals(self.comment.content, self.test_comment)
  59
  60
  61 class AttachmentPatchTest(InlinePatchTest):
  62     patch_filename = '0001-add-line.patch'
  63     test_comment = 'Test for attached patch'
  64     content_subtype = 'x-patch'
  65
  66     def setUp(self):
  67         self.orig_patch = read_patch(self.patch_filename)
  68         email = create_email(self.test_comment, multipart = True)
  69         attachment = MIMEText(self.orig_patch, _subtype = self.content_subtype)
  70         email.attach(attachment)
  71         (self.patch, self.comment) = find_content(self.project, email)
  72
  73 class AttachmentXDiffPatchTest(AttachmentPatchTest):
  74     content_subtype = 'x-diff'
  75
  76 class UTF8InlinePatchTest(InlinePatchTest):
  77     patch_filename = '0002-utf-8.patch'
  78     patch_encoding = 'utf-8'
  79
  80     def setUp(self):
  81         self.orig_patch = read_patch(self.patch_filename, self.patch_encoding)
  82         email = create_email(self.test_comment + '\n' + self.orig_patch,
  83                              content_encoding = self.patch_encoding)
  84         (self.patch, self.comment) = find_content(self.project, email)
  85
  86 class NoCharsetInlinePatchTest(InlinePatchTest):
  87     """ Test mails with no content-type or content-encoding header """
  88     patch_filename = '0001-add-line.patch'
  89
  90     def setUp(self):
  91         self.orig_patch = read_patch(self.patch_filename)
  92         email = create_email(self.test_comment + '\n' + self.orig_patch)
  93         del email['Content-Type']
  94         del email['Content-Transfer-Encoding']
  95         (self.patch, self.comment) = find_content(self.project, email)
  96
  97 class SignatureCommentTest(InlinePatchTest):
  98     patch_filename = '0001-add-line.patch'
  99     test_comment = 'Test comment\nmore comment'
 100
 101     def setUp(self):
 102         self.orig_patch = read_patch(self.patch_filename)
 103         email = create_email( \
 104                 self.test_comment + '\n' + \
 105                 '-- \nsig\n' + self.orig_patch)
 106         (self.patch, self.comment) = find_content(self.project, email)
 107
 108
 109 class ListFooterTest(InlinePatchTest):
 110     patch_filename = '0001-add-line.patch'
 111     test_comment = 'Test comment\nmore comment'
 112
 113     def setUp(self):
 114         self.orig_patch = read_patch(self.patch_filename)
 115         email = create_email( \
 116                 self.test_comment + '\n' + \
 117                 '_______________________________________________\n' + \
 118                 'Linuxppc-dev mailing list\n' + \
 119                 self.orig_patch)
 120         (self.patch, self.comment) = find_content(self.project, email)
 121
 122
 123 class DiffWordInCommentTest(InlinePatchTest):
 124     test_comment = 'Lines can start with words beginning in "diff"\n' + \
 125                    'difficult\nDifferent'
 126
 127
 128 class UpdateCommentTest(InlinePatchTest):
 129     """ Test for '---\nUpdate: v2' style comments to patches. """
 130     patch_filename = '0001-add-line.patch'
 131     test_comment = 'Test comment\nmore comment\n---\nUpdate: test update'
 132
 133 class UpdateSigCommentTest(SignatureCommentTest):
 134     """ Test for '---\nUpdate: v2' style comments to patches, with a sig """
 135     patch_filename = '0001-add-line.patch'
 136     test_comment = 'Test comment\nmore comment\n---\nUpdate: test update'
 137
 138 class SenderEncodingTest(TestCase):
 139     sender_name = u'example user'
 140     sender_email = 'user@example.com'
 141     from_header = 'example user <user@example.com>'
 142
 143     def setUp(self):
 144         mail = 'From: %s\n' % self.from_header + \
 145                'Subject: test\n\n' + \
 146                'test'
 147         self.email = message_from_string(mail)
 148         (self.person, new) = find_author(self.email)
 149         self.person.save()
 150
 151     def tearDown(self):
 152         self.person.delete()
 153
 154     def testName(self):
 155         self.assertEquals(self.person.name, self.sender_name)
 156
 157     def testEmail(self):
 158         self.assertEquals(self.person.email, self.sender_email)
 159
 160     def testDBQueryName(self):
 161         db_person = Person.objects.get(name = self.sender_name)
 162         self.assertEquals(self.person, db_person)
 163
 164     def testDBQueryEmail(self):
 165         db_person = Person.objects.get(email = self.sender_email)
 166         self.assertEquals(self.person, db_person)
 167
 168
 169 class SenderUTF8QPEncodingTest(SenderEncodingTest):
 170     sender_name = u'\xe9xample user'
 171     from_header = '=?utf-8?q?=C3=A9xample=20user?= <user@example.com>'
 172
 173 class SenderUTF8QPSplitEncodingTest(SenderEncodingTest):
 174     sender_name = u'\xe9xample user'
 175     from_header = '=?utf-8?q?=C3=A9xample?= user <user@example.com>'
 176
 177 class SenderUTF8B64EncodingTest(SenderUTF8QPEncodingTest):
 178     from_header = '=?utf-8?B?w6l4YW1wbGUgdXNlcg==?= <user@example.com>'
 179
 180 class SubjectEncodingTest(PatchTest):
 181     sender = 'example user <user@example.com>'
 182     subject = 'test subject'
 183     subject_header = 'test subject'
 184
 185     def setUp(self):
 186         mail = 'From: %s\n' % self.sender + \
 187                'Subject: %s\n\n' % self.subject_header + \
 188                'test\n\n' + defaults.patch
 189         self.projects = defaults.project
 190         self.email = message_from_string(mail)
 191
 192     def testSubjectEncoding(self):
 193         (patch, comment) = find_content(self.project, self.email)
 194         self.assertEquals(patch.name, self.subject)
 195
 196 class SubjectUTF8QPEncodingTest(SubjectEncodingTest):
 197     subject = u'test s\xfcbject'
 198     subject_header = '=?utf-8?q?test=20s=c3=bcbject?='
 199
 200 class SubjectUTF8QPMultipleEncodingTest(SubjectEncodingTest):
 201     subject = u'test s\xfcbject'
 202     subject_header = 'test =?utf-8?q?s=c3=bcbject?='
 203
 204 class SenderCorrelationTest(TestCase):
 205     existing_sender = 'Existing Sender <existing@example.com>'
 206     non_existing_sender = 'Non-existing Sender <nonexisting@example.com>'
 207
 208     def mail(self, sender):
 209         return message_from_string('From: %s\nSubject: Test\n\ntest\n' % sender)
 210
 211     def setUp(self):
 212         self.existing_sender_mail = self.mail(self.existing_sender)
 213         self.non_existing_sender_mail = self.mail(self.non_existing_sender)
 214         (self.person, new) = find_author(self.existing_sender_mail)
 215         self.person.save()
 216
 217     def testExisingSender(self):
 218         (person, new) = find_author(self.existing_sender_mail)
 219         self.assertEqual(new, False)
 220         self.assertEqual(person.id, self.person.id)
 221
 222     def testNonExisingSender(self):
 223         (person, new) = find_author(self.non_existing_sender_mail)
 224         self.assertEqual(new, True)
 225         self.assertEqual(person.id, None)
 226
 227     def testExistingDifferentFormat(self):
 228         mail = self.mail('existing@example.com')
 229         (person, new) = find_author(mail)
 230         self.assertEqual(new, False)
 231         self.assertEqual(person.id, self.person.id)
 232
 233     def testExistingDifferentCase(self):
 234         mail = self.mail(self.existing_sender.upper())
 235         (person, new) = find_author(mail)
 236         self.assertEqual(new, False)
 237         self.assertEqual(person.id, self.person.id)
 238
 239     def tearDown(self):
 240         self.person.delete()
 241
 242 class MultipleProjectPatchTest(TestCase):
 243     """ Test that patches sent to multiple patchwork projects are
 244         handled correctly """
 245
 246     fixtures = ['default_states']
 247     test_comment = 'Test Comment'
 248     patch_filename = '0001-add-line.patch'
 249     msgid = '<1@example.com>'
 250
 251     def setUp(self):
 252         self.p1 = Project(linkname = 'test-project-1', name = 'Project 1',
 253                 listid = '1.example.com', listemail='1@example.com')
 254         self.p2 = Project(linkname = 'test-project-2', name = 'Project 2',
 255                 listid = '2.example.com', listemail='2@example.com')
 256
 257         self.p1.save()
 258         self.p2.save()
 259
 260         patch = read_patch(self.patch_filename)
 261         email = create_email(self.test_comment + '\n' + patch)
 262         email['Message-Id'] = self.msgid
 263
 264         del email['List-ID']
 265         email['List-ID'] = '<' + self.p1.listid + '>'
 266         parse_mail(email)
 267
 268         del email['List-ID']
 269         email['List-ID'] = '<' + self.p2.listid + '>'
 270         parse_mail(email)
 271
 272     def testParsedProjects(self):
 273         self.assertEquals(Patch.objects.filter(project = self.p1).count(), 1)
 274         self.assertEquals(Patch.objects.filter(project = self.p2).count(), 1)
 275
 276     def tearDown(self):
 277         self.p1.delete()
 278         self.p2.delete()
 279
 280
 281 class MultipleProjectPatchCommentTest(MultipleProjectPatchTest):
 282     """ Test that followups to multiple-project patches end up on the
 283         correct patch """
 284
 285     comment_msgid = '<2@example.com>'
 286     comment_content = 'test comment'
 287
 288     def setUp(self):
 289         super(MultipleProjectPatchCommentTest, self).setUp()
 290
 291         for project in [self.p1, self.p2]:
 292             email = MIMEText(self.comment_content)
 293             email['From'] = defaults.sender
 294             email['Subject'] = defaults.subject
 295             email['Message-Id'] = self.comment_msgid
 296             email['List-ID'] = '<' + project.listid + '>'
 297             email['In-Reply-To'] = self.msgid
 298             parse_mail(email)
 299
 300     def testParsedComment(self):
 301         for project in [self.p1, self.p2]:
 302             patch = Patch.objects.filter(project = project)[0]
 303             # we should see two comments now - the original mail with the patch,
 304             # and the one we parsed in setUp()
 305             self.assertEquals(Comment.objects.filter(patch = patch).count(), 2)
 306
 307 class ListIdHeaderTest(TestCase):
 308     """ Test that we parse List-Id headers from mails correctly """
 309     def setUp(self):
 310         self.project = Project(linkname = 'test-project-1', name = 'Project 1',
 311                 listid = '1.example.com', listemail='1@example.com')
 312         self.project.save()
 313
 314     def testNoListId(self):
 315         email = MIMEText('')
 316         project = find_project(email)
 317         self.assertEquals(project, None)
 318
 319     def testBlankListId(self):
 320         email = MIMEText('')
 321         email['List-Id'] = ''
 322         project = find_project(email)
 323         self.assertEquals(project, None)
 324
 325     def testWhitespaceListId(self):
 326         email = MIMEText('')
 327         email['List-Id'] = ' '
 328         project = find_project(email)
 329         self.assertEquals(project, None)
 330
 331     def testSubstringListId(self):
 332         email = MIMEText('')
 333         email['List-Id'] = 'example.com'
 334         project = find_project(email)
 335         self.assertEquals(project, None)
 336
 337     def testShortListId(self):
 338         """ Some mailing lists have List-Id headers in short formats, where it
 339             is only the list ID itself (without enclosing angle-brackets). """
 340         email = MIMEText('')
 341         email['List-Id'] = self.project.listid
 342         project = find_project(email)
 343         self.assertEquals(project, self.project)
 344
 345     def testLongListId(self):
 346         email = MIMEText('')
 347         email['List-Id'] = 'Test text <%s>' % self.project.listid
 348         project = find_project(email)
 349         self.assertEquals(project, self.project)
 350
 351     def tearDown(self):
 352         self.project.delete()
 353
 354 class MBoxPatchTest(PatchTest):
 355     def setUp(self):
 356         self.mail = read_mail(self.mail_file, project = self.project)
 357
 358 class GitPullTest(MBoxPatchTest):
 359     mail_file = '0001-git-pull-request.mbox'
 360
 361     def testGitPullRequest(self):
 362         (patch, comment) = find_content(self.project, self.mail)
 363         self.assertTrue(patch is not None)
 364         self.assertTrue(patch.pull_url is not None)
 365         self.assertTrue(patch.content is None)
 366         self.assertTrue(comment is not None)
 367
 368 class GitPullWrappedTest(GitPullTest):
 369     mail_file = '0002-git-pull-request-wrapped.mbox'
 370
 371 class GitPullWithDiffTest(MBoxPatchTest):
 372     mail_file = '0003-git-pull-request-with-diff.mbox'
 373
 374     def testGitPullWithDiff(self):
 375         (patch, comment) = find_content(self.project, self.mail)
 376         self.assertTrue(patch is not None)
 377         self.assertEqual('git://git.kernel.org/pub/scm/linux/kernel/git/tip/' +
 378              'linux-2.6-tip.git x86-fixes-for-linus', patch.pull_url)
 379         self.assertTrue(
 380             patch.content.startswith('diff --git a/arch/x86/include/asm/smp.h'),
 381             patch.content)
 382         self.assertTrue(comment is not None)
 383
 384 class GitPullGitSSHUrlTest(GitPullTest):
 385     mail_file = '0004-git-pull-request-git+ssh.mbox'
 386
 387 class GitPullSSHUrlTest(GitPullTest):
 388     mail_file = '0005-git-pull-request-ssh.mbox'
 389
 390 class GitPullHTTPUrlTest(GitPullTest):
 391     mail_file = '0006-git-pull-request-http.mbox'
 392
 393 class GitRenameOnlyTest(MBoxPatchTest):
 394     mail_file = '0008-git-rename.mbox'
 395
 396     def testGitRename(self):
 397         (patch, comment) = find_content(self.project, self.mail)
 398         self.assertTrue(patch is not None)
 399         self.assertTrue(comment is not None)
 400         self.assertEqual(patch.content.count("\nrename from "), 2)
 401         self.assertEqual(patch.content.count("\nrename to "), 2)
 402
 403 class GitRenameWithDiffTest(MBoxPatchTest):
 404     mail_file = '0009-git-rename-with-diff.mbox'
 405
 406     def testGitRename(self):
 407         (patch, comment) = find_content(self.project, self.mail)
 408         self.assertTrue(patch is not None)
 409         self.assertTrue(comment is not None)
 410         self.assertEqual(patch.content.count("\nrename from "), 2)
 411         self.assertEqual(patch.content.count("\nrename to "), 2)
 412         self.assertEqual(patch.content.count('\n-a\n+b'), 1)
 413
 414 class CVSFormatPatchTest(MBoxPatchTest):
 415     mail_file = '0007-cvs-format-diff.mbox'
 416
 417     def testPatch(self):
 418         (patch, comment) = find_content(self.project, self.mail)
 419         self.assertTrue(patch is not None)
 420         self.assertTrue(comment is not None)
 421         self.assertTrue(patch.content.startswith('Index'))
 422
 423 class CharsetFallbackPatchTest(MBoxPatchTest):
 424     """ Test mail with and invalid charset name, and check that we can parse
 425         with one of the fallback encodings"""
 426
 427     mail_file = '0010-invalid-charset.mbox'
 428
 429     def testPatch(self):
 430         (patch, comment) = find_content(self.project, self.mail)
 431         self.assertTrue(patch is not None)
 432         self.assertTrue(comment is not None)
 433
 434 class NoNewlineAtEndOfFilePatchTest(MBoxPatchTest):
 435     mail_file = '0011-no-newline-at-end-of-file.mbox'
 436
 437     def testPatch(self):
 438         (patch, comment) = find_content(self.project, self.mail)
 439         self.assertTrue(patch is not None)
 440         self.assertTrue(comment is not None)
 441         self.assertTrue(patch.content.startswith('diff --git a/tools/testing/selftests/powerpc/Makefile'))
 442         # Confirm the trailing no newline marker doesn't end up in the comment
 443         self.assertFalse(comment.content.rstrip().endswith('\ No newline at end of file'))
 444         # Confirm it's instead at the bottom of the patch
 445         self.assertTrue(patch.content.rstrip().endswith('\ No newline at end of file'))
 446         # Confirm we got both markers
 447         self.assertEqual(2, patch.content.count('\ No newline at end of file'))
 448
 449 class DelegateRequestTest(TestCase):
 450     fixtures = ['default_states']
 451     patch_filename = '0001-add-line.patch'
 452     msgid = '<1@example.com>'
 453     invalid_delegate_email = "nobody"
 454
 455     def setUp(self):
 456         self.patch = read_patch(self.patch_filename)
 457         self.user = create_user()
 458         self.p1 = Project(linkname = 'test-project-1', name = 'Project 1',
 459                 listid = '1.example.com', listemail='1@example.com')
 460         self.p1.save()
 461
 462     def get_email(self):
 463         email = create_email(self.patch)
 464         del email['List-ID']
 465         email['List-ID'] = '<' + self.p1.listid + '>'
 466         email['Message-Id'] = self.msgid
 467         return email
 468
 469     def _assertDelegate(self, delegate):
 470         query = Patch.objects.filter(project=self.p1)
 471         self.assertEquals(query.count(), 1)
 472         self.assertEquals(query[0].delegate, delegate)
 473
 474     def testDelegate(self):
 475         email = self.get_email()
 476         email['X-Patchwork-Delegate'] = self.user.email
 477         parse_mail(email)
 478         self._assertDelegate(self.user)
 479
 480     def testNoDelegate(self):
 481         email = self.get_email()
 482         parse_mail(email)
 483         self._assertDelegate(None)
 484
 485     def testInvalidDelegateFallsBackToNoDelegate(self):
 486         email = self.get_email()
 487         email['X-Patchwork-Delegate'] = self.invalid_delegate_email
 488         parse_mail(email)
 489         self._assertDelegate(None)
 490
 491     def tearDown(self):
 492         self.p1.delete()
 493         self.user.delete()
 494
 495 class InitialPatchStateTest(TestCase):
 496     fixtures = ['default_states']
 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', 'default_states']
 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)
 582
 583 class PrefixTest(TestCase):
 584
 585     def testSplitPrefixes(self):
 586         self.assertEquals(split_prefixes('PATCH'), ['PATCH'])
 587         self.assertEquals(split_prefixes('PATCH,RFC'), ['PATCH', 'RFC'])
 588         self.assertEquals(split_prefixes(''), [])
 589         self.assertEquals(split_prefixes('PATCH,'), ['PATCH'])
 590         self.assertEquals(split_prefixes('PATCH '), ['PATCH'])
 591         self.assertEquals(split_prefixes('PATCH,RFC'), ['PATCH', 'RFC'])
 592         self.assertEquals(split_prefixes('PATCH 1/2'), ['PATCH', '1/2'])
 593
 594 class SubjectTest(TestCase):
 595
 596     def testCleanSubject(self):
 597         self.assertEquals(clean_subject('meep'), 'meep')
 598         self.assertEquals(clean_subject('Re: meep'), 'meep')
 599         self.assertEquals(clean_subject('[PATCH] meep'), 'meep')
 600         self.assertEquals(clean_subject('[PATCH] meep \n meep'), 'meep meep')
 601         self.assertEquals(clean_subject('[PATCH RFC] meep'), '[RFC] meep')
 602         self.assertEquals(clean_subject('[PATCH,RFC] meep'), '[RFC] meep')
 603         self.assertEquals(clean_subject('[PATCH,1/2] meep'), '[1/2] meep')
 604         self.assertEquals(clean_subject('[PATCH RFC 1/2] meep'),
 605                                             '[RFC,1/2] meep')
 606         self.assertEquals(clean_subject('[PATCH] [RFC] meep'),
 607                                             '[RFC] meep')
 608         self.assertEquals(clean_subject('[PATCH] [RFC,1/2] meep'),
 609                                             '[RFC,1/2] meep')
 610         self.assertEquals(clean_subject('[PATCH] [RFC] [1/2] meep'),
 611                                             '[RFC,1/2] meep')
 612         self.assertEquals(clean_subject('[PATCH] rewrite [a-z] regexes'),
 613                                             'rewrite [a-z] regexes')
 614         self.assertEquals(clean_subject('[PATCH] [RFC] rewrite [a-z] regexes'),
 615                                             '[RFC] rewrite [a-z] regexes')
 616         self.assertEquals(clean_subject('[foo] [bar] meep', ['foo']),
 617                                             '[bar] meep')
 618         self.assertEquals(clean_subject('[FOO] [bar] meep', ['foo']),
 619                                             '[bar] meep')