1 # Patchwork - automated patch tracking system
2 # Copyright (C) 2008 Jeremy Kerr <jk@ozlabs.org>
4 # This file is part of the Patchwork package.
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.
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.
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
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, \
29 from email.mime.text import MIMEText
31 # Python 2.4 compatibility
32 from email.MIMEText import MIMEText
34 class PatchTest(TestCase):
35 fixtures = ['default_states']
36 default_sender = defaults.sender
37 default_subject = defaults.subject
38 project = defaults.project
40 from patchwork.bin.parsemail import find_content, find_author, find_project, \
41 parse_mail, split_prefixes, clean_subject
43 class InlinePatchTest(PatchTest):
44 patch_filename = '0001-add-line.patch'
45 test_comment = 'Test for attached patch'
48 self.orig_patch = read_patch(self.patch_filename)
49 email = create_email(self.test_comment + '\n' + self.orig_patch)
50 (self.patch, self.comment) = find_content(self.project, email)
52 def testPatchPresence(self):
53 self.assertTrue(self.patch is not None)
55 def testPatchContent(self):
56 self.assertEquals(self.patch.content, self.orig_patch)
58 def testCommentPresence(self):
59 self.assertTrue(self.comment is not None)
61 def testCommentContent(self):
62 self.assertEquals(self.comment.content, self.test_comment)
65 class AttachmentPatchTest(InlinePatchTest):
66 patch_filename = '0001-add-line.patch'
67 test_comment = 'Test for attached patch'
68 content_subtype = 'x-patch'
71 self.orig_patch = read_patch(self.patch_filename)
72 email = create_email(self.test_comment, multipart = True)
73 attachment = MIMEText(self.orig_patch, _subtype = self.content_subtype)
74 email.attach(attachment)
75 (self.patch, self.comment) = find_content(self.project, email)
77 class AttachmentXDiffPatchTest(AttachmentPatchTest):
78 content_subtype = 'x-diff'
80 class UTF8InlinePatchTest(InlinePatchTest):
81 patch_filename = '0002-utf-8.patch'
82 patch_encoding = 'utf-8'
85 self.orig_patch = read_patch(self.patch_filename, self.patch_encoding)
86 email = create_email(self.test_comment + '\n' + self.orig_patch,
87 content_encoding = self.patch_encoding)
88 (self.patch, self.comment) = find_content(self.project, email)
90 class NoCharsetInlinePatchTest(InlinePatchTest):
91 """ Test mails with no content-type or content-encoding header """
92 patch_filename = '0001-add-line.patch'
95 self.orig_patch = read_patch(self.patch_filename)
96 email = create_email(self.test_comment + '\n' + self.orig_patch)
97 del email['Content-Type']
98 del email['Content-Transfer-Encoding']
99 (self.patch, self.comment) = find_content(self.project, email)
101 class SignatureCommentTest(InlinePatchTest):
102 patch_filename = '0001-add-line.patch'
103 test_comment = 'Test comment\nmore comment'
106 self.orig_patch = read_patch(self.patch_filename)
107 email = create_email( \
108 self.test_comment + '\n' + \
109 '-- \nsig\n' + self.orig_patch)
110 (self.patch, self.comment) = find_content(self.project, email)
113 class ListFooterTest(InlinePatchTest):
114 patch_filename = '0001-add-line.patch'
115 test_comment = 'Test comment\nmore comment'
118 self.orig_patch = read_patch(self.patch_filename)
119 email = create_email( \
120 self.test_comment + '\n' + \
121 '_______________________________________________\n' + \
122 'Linuxppc-dev mailing list\n' + \
124 (self.patch, self.comment) = find_content(self.project, email)
127 class DiffWordInCommentTest(InlinePatchTest):
128 test_comment = 'Lines can start with words beginning in "diff"\n' + \
129 'difficult\nDifferent'
132 class UpdateCommentTest(InlinePatchTest):
133 """ Test for '---\nUpdate: v2' style comments to patches. """
134 patch_filename = '0001-add-line.patch'
135 test_comment = 'Test comment\nmore comment\n---\nUpdate: test update'
137 class UpdateSigCommentTest(SignatureCommentTest):
138 """ Test for '---\nUpdate: v2' style comments to patches, with a sig """
139 patch_filename = '0001-add-line.patch'
140 test_comment = 'Test comment\nmore comment\n---\nUpdate: test update'
142 class SenderEncodingTest(TestCase):
143 sender_name = u'example user'
144 sender_email = 'user@example.com'
145 from_header = 'example user <user@example.com>'
148 mail = 'From: %s\n' % self.from_header + \
149 'Subject: test\n\n' + \
151 self.email = message_from_string(mail)
152 (self.person, new) = find_author(self.email)
159 self.assertEquals(self.person.name, self.sender_name)
162 self.assertEquals(self.person.email, self.sender_email)
164 def testDBQueryName(self):
165 db_person = Person.objects.get(name = self.sender_name)
166 self.assertEquals(self.person, db_person)
168 def testDBQueryEmail(self):
169 db_person = Person.objects.get(email = self.sender_email)
170 self.assertEquals(self.person, db_person)
173 class SenderUTF8QPEncodingTest(SenderEncodingTest):
174 sender_name = u'\xe9xample user'
175 from_header = '=?utf-8?q?=C3=A9xample=20user?= <user@example.com>'
177 class SenderUTF8QPSplitEncodingTest(SenderEncodingTest):
178 sender_name = u'\xe9xample user'
179 from_header = '=?utf-8?q?=C3=A9xample?= user <user@example.com>'
181 class SenderUTF8B64EncodingTest(SenderUTF8QPEncodingTest):
182 from_header = '=?utf-8?B?w6l4YW1wbGUgdXNlcg==?= <user@example.com>'
184 class SubjectEncodingTest(PatchTest):
185 sender = 'example user <user@example.com>'
186 subject = 'test subject'
187 subject_header = 'test subject'
190 mail = 'From: %s\n' % self.sender + \
191 'Subject: %s\n\n' % self.subject_header + \
192 'test\n\n' + defaults.patch
193 self.projects = defaults.project
194 self.email = message_from_string(mail)
196 def testSubjectEncoding(self):
197 (patch, comment) = find_content(self.project, self.email)
198 self.assertEquals(patch.name, self.subject)
200 class SubjectUTF8QPEncodingTest(SubjectEncodingTest):
201 subject = u'test s\xfcbject'
202 subject_header = '=?utf-8?q?test=20s=c3=bcbject?='
204 class SubjectUTF8QPMultipleEncodingTest(SubjectEncodingTest):
205 subject = u'test s\xfcbject'
206 subject_header = 'test =?utf-8?q?s=c3=bcbject?='
208 class SenderCorrelationTest(TestCase):
209 existing_sender = 'Existing Sender <existing@example.com>'
210 non_existing_sender = 'Non-existing Sender <nonexisting@example.com>'
212 def mail(self, sender):
213 return message_from_string('From: %s\nSubject: Test\n\ntest\n' % sender)
216 self.existing_sender_mail = self.mail(self.existing_sender)
217 self.non_existing_sender_mail = self.mail(self.non_existing_sender)
218 (self.person, new) = find_author(self.existing_sender_mail)
221 def testExisingSender(self):
222 (person, new) = find_author(self.existing_sender_mail)
223 self.assertEqual(new, False)
224 self.assertEqual(person.id, self.person.id)
226 def testNonExisingSender(self):
227 (person, new) = find_author(self.non_existing_sender_mail)
228 self.assertEqual(new, True)
229 self.assertEqual(person.id, None)
231 def testExistingDifferentFormat(self):
232 mail = self.mail('existing@example.com')
233 (person, new) = find_author(mail)
234 self.assertEqual(new, False)
235 self.assertEqual(person.id, self.person.id)
237 def testExistingDifferentCase(self):
238 mail = self.mail(self.existing_sender.upper())
239 (person, new) = find_author(mail)
240 self.assertEqual(new, False)
241 self.assertEqual(person.id, self.person.id)
246 class MultipleProjectPatchTest(TestCase):
247 """ Test that patches sent to multiple patchwork projects are
248 handled correctly """
250 fixtures = ['default_states']
251 test_comment = 'Test Comment'
252 patch_filename = '0001-add-line.patch'
253 msgid = '<1@example.com>'
256 self.p1 = Project(linkname = 'test-project-1', name = 'Project 1',
257 listid = '1.example.com', listemail='1@example.com')
258 self.p2 = Project(linkname = 'test-project-2', name = 'Project 2',
259 listid = '2.example.com', listemail='2@example.com')
264 patch = read_patch(self.patch_filename)
265 email = create_email(self.test_comment + '\n' + patch)
266 email['Message-Id'] = self.msgid
269 email['List-ID'] = '<' + self.p1.listid + '>'
273 email['List-ID'] = '<' + self.p2.listid + '>'
276 def testParsedProjects(self):
277 self.assertEquals(Patch.objects.filter(project = self.p1).count(), 1)
278 self.assertEquals(Patch.objects.filter(project = self.p2).count(), 1)
285 class MultipleProjectPatchCommentTest(MultipleProjectPatchTest):
286 """ Test that followups to multiple-project patches end up on the
289 comment_msgid = '<2@example.com>'
290 comment_content = 'test comment'
293 super(MultipleProjectPatchCommentTest, self).setUp()
295 for project in [self.p1, self.p2]:
296 email = MIMEText(self.comment_content)
297 email['From'] = defaults.sender
298 email['Subject'] = defaults.subject
299 email['Message-Id'] = self.comment_msgid
300 email['List-ID'] = '<' + project.listid + '>'
301 email['In-Reply-To'] = self.msgid
304 def testParsedComment(self):
305 for project in [self.p1, self.p2]:
306 patch = Patch.objects.filter(project = project)[0]
307 # we should see two comments now - the original mail with the patch,
308 # and the one we parsed in setUp()
309 self.assertEquals(Comment.objects.filter(patch = patch).count(), 2)
311 class ListIdHeaderTest(TestCase):
312 """ Test that we parse List-Id headers from mails correctly """
314 self.project = Project(linkname = 'test-project-1', name = 'Project 1',
315 listid = '1.example.com', listemail='1@example.com')
318 def testNoListId(self):
320 project = find_project(email)
321 self.assertEquals(project, None)
323 def testBlankListId(self):
325 email['List-Id'] = ''
326 project = find_project(email)
327 self.assertEquals(project, None)
329 def testWhitespaceListId(self):
331 email['List-Id'] = ' '
332 project = find_project(email)
333 self.assertEquals(project, None)
335 def testSubstringListId(self):
337 email['List-Id'] = 'example.com'
338 project = find_project(email)
339 self.assertEquals(project, None)
341 def testShortListId(self):
342 """ Some mailing lists have List-Id headers in short formats, where it
343 is only the list ID itself (without enclosing angle-brackets). """
345 email['List-Id'] = self.project.listid
346 project = find_project(email)
347 self.assertEquals(project, self.project)
349 def testLongListId(self):
351 email['List-Id'] = 'Test text <%s>' % self.project.listid
352 project = find_project(email)
353 self.assertEquals(project, self.project)
356 self.project.delete()
358 class MBoxPatchTest(PatchTest):
360 self.mail = read_mail(self.mail_file, project = self.project)
362 class GitPullTest(MBoxPatchTest):
363 mail_file = '0001-git-pull-request.mbox'
365 def testGitPullRequest(self):
366 (patch, comment) = find_content(self.project, self.mail)
367 self.assertTrue(patch is not None)
368 self.assertTrue(patch.pull_url is not None)
369 self.assertTrue(patch.content is None)
370 self.assertTrue(comment is not None)
372 class GitPullWrappedTest(GitPullTest):
373 mail_file = '0002-git-pull-request-wrapped.mbox'
375 class GitPullWithDiffTest(MBoxPatchTest):
376 mail_file = '0003-git-pull-request-with-diff.mbox'
378 def testGitPullWithDiff(self):
379 (patch, comment) = find_content(self.project, self.mail)
380 self.assertTrue(patch is not None)
381 self.assertEqual('git://git.kernel.org/pub/scm/linux/kernel/git/tip/' +
382 'linux-2.6-tip.git x86-fixes-for-linus', patch.pull_url)
384 patch.content.startswith('diff --git a/arch/x86/include/asm/smp.h'),
386 self.assertTrue(comment is not None)
388 class GitPullGitSSHUrlTest(GitPullTest):
389 mail_file = '0004-git-pull-request-git+ssh.mbox'
391 class GitPullSSHUrlTest(GitPullTest):
392 mail_file = '0005-git-pull-request-ssh.mbox'
394 class GitPullHTTPUrlTest(GitPullTest):
395 mail_file = '0006-git-pull-request-http.mbox'
397 class GitRenameOnlyTest(MBoxPatchTest):
398 mail_file = '0008-git-rename.mbox'
400 def testGitRename(self):
401 (patch, comment) = find_content(self.project, self.mail)
402 self.assertTrue(patch is not None)
403 self.assertTrue(comment is not None)
404 self.assertEqual(patch.content.count("\nrename from "), 2)
405 self.assertEqual(patch.content.count("\nrename to "), 2)
407 class GitRenameWithDiffTest(MBoxPatchTest):
408 mail_file = '0009-git-rename-with-diff.mbox'
410 def testGitRename(self):
411 (patch, comment) = find_content(self.project, self.mail)
412 self.assertTrue(patch is not None)
413 self.assertTrue(comment is not None)
414 self.assertEqual(patch.content.count("\nrename from "), 2)
415 self.assertEqual(patch.content.count("\nrename to "), 2)
416 self.assertEqual(patch.content.count('\n-a\n+b'), 1)
418 class CVSFormatPatchTest(MBoxPatchTest):
419 mail_file = '0007-cvs-format-diff.mbox'
422 (patch, comment) = find_content(self.project, self.mail)
423 self.assertTrue(patch is not None)
424 self.assertTrue(comment is not None)
425 self.assertTrue(patch.content.startswith('Index'))
427 class CharsetFallbackPatchTest(MBoxPatchTest):
428 """ Test mail with and invalid charset name, and check that we can parse
429 with one of the fallback encodings"""
431 mail_file = '0010-invalid-charset.mbox'
434 (patch, comment) = find_content(self.project, self.mail)
435 self.assertTrue(patch is not None)
436 self.assertTrue(comment is not None)
438 class NoNewlineAtEndOfFilePatchTest(MBoxPatchTest):
439 mail_file = '0011-no-newline-at-end-of-file.mbox'
442 (patch, comment) = find_content(self.project, self.mail)
443 self.assertTrue(patch is not None)
444 self.assertTrue(comment is not None)
445 self.assertTrue(patch.content.startswith('diff --git a/tools/testing/selftests/powerpc/Makefile'))
446 # Confirm the trailing no newline marker doesn't end up in the comment
447 self.assertFalse(comment.content.rstrip().endswith('\ No newline at end of file'))
448 # Confirm it's instead at the bottom of the patch
449 self.assertTrue(patch.content.rstrip().endswith('\ No newline at end of file'))
450 # Confirm we got both markers
451 self.assertEqual(2, patch.content.count('\ No newline at end of file'))
453 class DelegateRequestTest(TestCase):
454 fixtures = ['default_states']
455 patch_filename = '0001-add-line.patch'
456 msgid = '<1@example.com>'
457 invalid_delegate_email = "nobody"
460 self.patch = read_patch(self.patch_filename)
461 self.user = create_user()
462 self.p1 = Project(linkname = 'test-project-1', name = 'Project 1',
463 listid = '1.example.com', listemail='1@example.com')
467 email = create_email(self.patch)
469 email['List-ID'] = '<' + self.p1.listid + '>'
470 email['Message-Id'] = self.msgid
473 def _assertDelegate(self, delegate):
474 query = Patch.objects.filter(project=self.p1)
475 self.assertEquals(query.count(), 1)
476 self.assertEquals(query[0].delegate, delegate)
478 def testDelegate(self):
479 email = self.get_email()
480 email['X-Patchwork-Delegate'] = self.user.email
482 self._assertDelegate(self.user)
484 def testNoDelegate(self):
485 email = self.get_email()
487 self._assertDelegate(None)
489 def testInvalidDelegateFallsBackToNoDelegate(self):
490 email = self.get_email()
491 email['X-Patchwork-Delegate'] = self.invalid_delegate_email
493 self._assertDelegate(None)
499 class InitialPatchStateTest(TestCase):
500 fixtures = ['default_states']
501 patch_filename = '0001-add-line.patch'
502 msgid = '<1@example.com>'
503 invalid_state_name = "Nonexistent Test State"
506 self.patch = read_patch(self.patch_filename)
507 self.user = create_user()
508 self.p1 = Project(linkname = 'test-project-1', name = 'Project 1',
509 listid = '1.example.com', listemail='1@example.com')
511 self.default_state = get_default_initial_patch_state()
512 self.nondefault_state = State.objects.get(name="Accepted")
515 email = create_email(self.patch)
517 email['List-ID'] = '<' + self.p1.listid + '>'
518 email['Message-Id'] = self.msgid
521 def _assertState(self, state):
522 query = Patch.objects.filter(project=self.p1)
523 self.assertEquals(query.count(), 1)
524 self.assertEquals(query[0].state, state)
526 def testNonDefaultStateIsActuallyNotTheDefaultState(self):
527 self.assertNotEqual(self.default_state, self.nondefault_state)
529 def testExplicitNonDefaultStateRequest(self):
530 email = self.get_email()
531 email['X-Patchwork-State'] = self.nondefault_state.name
533 self._assertState(self.nondefault_state)
535 def testExplicitDefaultStateRequest(self):
536 email = self.get_email()
537 email['X-Patchwork-State'] = self.default_state.name
539 self._assertState(self.default_state)
541 def testImplicitDefaultStateRequest(self):
542 email = self.get_email()
544 self._assertState(self.default_state)
546 def testInvalidTestStateDoesNotExist(self):
547 with self.assertRaises(State.DoesNotExist):
548 State.objects.get(name=self.invalid_state_name)
550 def testInvalidStateRequestFallsBackToDefaultState(self):
551 email = self.get_email()
552 email['X-Patchwork-State'] = self.invalid_state_name
554 self._assertState(self.default_state)
560 class ParseInitialTagsTest(PatchTest):
561 patch_filename = '0001-add-line.patch'
562 test_comment = ('test comment\n\n' +
563 'Tested-by: Test User <test@example.com>\n' +
564 'Reviewed-by: Test User <test@example.com>\n')
565 fixtures = ['default_tags', 'default_states']
568 project = defaults.project
569 project.listid = 'test.example.com'
571 self.orig_patch = read_patch(self.patch_filename)
572 email = create_email(self.test_comment + '\n' + self.orig_patch,
574 email['Message-Id'] = '<1@example.com>'
578 self.assertEquals(Patch.objects.count(), 1)
579 patch = Patch.objects.all()[0]
580 self.assertEquals(patch.patchtag_set.filter(
581 tag__name='Acked-by').count(), 0)
582 self.assertEquals(patch.patchtag_set.get(
583 tag__name='Reviewed-by').count, 1)
584 self.assertEquals(patch.patchtag_set.get(
585 tag__name='Tested-by').count, 1)
587 class PrefixTest(TestCase):
589 def testSplitPrefixes(self):
590 self.assertEquals(split_prefixes('PATCH'), ['PATCH'])
591 self.assertEquals(split_prefixes('PATCH,RFC'), ['PATCH', 'RFC'])
592 self.assertEquals(split_prefixes(''), [])
593 self.assertEquals(split_prefixes('PATCH,'), ['PATCH'])
594 self.assertEquals(split_prefixes('PATCH '), ['PATCH'])
595 self.assertEquals(split_prefixes('PATCH,RFC'), ['PATCH', 'RFC'])
596 self.assertEquals(split_prefixes('PATCH 1/2'), ['PATCH', '1/2'])
598 class SubjectTest(TestCase):
600 def testCleanSubject(self):
601 self.assertEquals(clean_subject('meep'), 'meep')
602 self.assertEquals(clean_subject('Re: meep'), 'meep')
603 self.assertEquals(clean_subject('[PATCH] meep'), 'meep')
604 self.assertEquals(clean_subject('[PATCH] meep \n meep'), 'meep meep')
605 self.assertEquals(clean_subject('[PATCH RFC] meep'), '[RFC] meep')
606 self.assertEquals(clean_subject('[PATCH,RFC] meep'), '[RFC] meep')
607 self.assertEquals(clean_subject('[PATCH,1/2] meep'), '[1/2] meep')
608 self.assertEquals(clean_subject('[PATCH RFC 1/2] meep'),
610 self.assertEquals(clean_subject('[PATCH] [RFC] meep'),
612 self.assertEquals(clean_subject('[PATCH] [RFC,1/2] meep'),
614 self.assertEquals(clean_subject('[PATCH] [RFC] [1/2] meep'),
616 self.assertEquals(clean_subject('[PATCH] rewrite [a-z] regexes'),
617 'rewrite [a-z] regexes')
618 self.assertEquals(clean_subject('[PATCH] [RFC] rewrite [a-z] regexes'),
619 '[RFC] rewrite [a-z] regexes')
620 self.assertEquals(clean_subject('[foo] [bar] meep', ['foo']),
622 self.assertEquals(clean_subject('[FOO] [bar] meep', ['foo']),