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, \
28 from email.mime.text import MIMEText
30 class PatchTest(TestCase):
31 fixtures = ['default_states']
32 default_sender = defaults.sender
33 default_subject = defaults.subject
34 project = defaults.project
36 from patchwork.bin.parsemail import find_content, find_author, find_project, \
37 parse_mail, split_prefixes, clean_subject
39 class InlinePatchTest(PatchTest):
40 patch_filename = '0001-add-line.patch'
41 test_comment = 'Test for attached patch'
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)
48 def testPatchPresence(self):
49 self.assertTrue(self.patch is not None)
51 def testPatchContent(self):
52 self.assertEquals(self.patch.content, self.orig_patch)
54 def testCommentPresence(self):
55 self.assertTrue(self.comment is not None)
57 def testCommentContent(self):
58 self.assertEquals(self.comment.content, self.test_comment)
61 class AttachmentPatchTest(InlinePatchTest):
62 patch_filename = '0001-add-line.patch'
63 test_comment = 'Test for attached patch'
64 content_subtype = 'x-patch'
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)
73 class AttachmentXDiffPatchTest(AttachmentPatchTest):
74 content_subtype = 'x-diff'
76 class UTF8InlinePatchTest(InlinePatchTest):
77 patch_filename = '0002-utf-8.patch'
78 patch_encoding = 'utf-8'
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)
86 class NoCharsetInlinePatchTest(InlinePatchTest):
87 """ Test mails with no content-type or content-encoding header """
88 patch_filename = '0001-add-line.patch'
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)
97 class SignatureCommentTest(InlinePatchTest):
98 patch_filename = '0001-add-line.patch'
99 test_comment = 'Test comment\nmore comment'
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)
109 class ListFooterTest(InlinePatchTest):
110 patch_filename = '0001-add-line.patch'
111 test_comment = 'Test comment\nmore comment'
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' + \
120 (self.patch, self.comment) = find_content(self.project, email)
123 class DiffWordInCommentTest(InlinePatchTest):
124 test_comment = 'Lines can start with words beginning in "diff"\n' + \
125 'difficult\nDifferent'
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'
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'
138 class SenderEncodingTest(TestCase):
139 sender_name = u'example user'
140 sender_email = 'user@example.com'
141 from_header = 'example user <user@example.com>'
144 mail = 'From: %s\n' % self.from_header + \
145 'Subject: test\n\n' + \
147 self.email = message_from_string(mail)
148 (self.person, new) = find_author(self.email)
155 self.assertEquals(self.person.name, self.sender_name)
158 self.assertEquals(self.person.email, self.sender_email)
160 def testDBQueryName(self):
161 db_person = Person.objects.get(name = self.sender_name)
162 self.assertEquals(self.person, db_person)
164 def testDBQueryEmail(self):
165 db_person = Person.objects.get(email = self.sender_email)
166 self.assertEquals(self.person, db_person)
169 class SenderUTF8QPEncodingTest(SenderEncodingTest):
170 sender_name = u'\xe9xample user'
171 from_header = '=?utf-8?q?=C3=A9xample=20user?= <user@example.com>'
173 class SenderUTF8QPSplitEncodingTest(SenderEncodingTest):
174 sender_name = u'\xe9xample user'
175 from_header = '=?utf-8?q?=C3=A9xample?= user <user@example.com>'
177 class SenderUTF8B64EncodingTest(SenderUTF8QPEncodingTest):
178 from_header = '=?utf-8?B?w6l4YW1wbGUgdXNlcg==?= <user@example.com>'
180 class SubjectEncodingTest(PatchTest):
181 sender = 'example user <user@example.com>'
182 subject = 'test subject'
183 subject_header = 'test subject'
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)
192 def testSubjectEncoding(self):
193 (patch, comment) = find_content(self.project, self.email)
194 self.assertEquals(patch.name, self.subject)
196 class SubjectUTF8QPEncodingTest(SubjectEncodingTest):
197 subject = u'test s\xfcbject'
198 subject_header = '=?utf-8?q?test=20s=c3=bcbject?='
200 class SubjectUTF8QPMultipleEncodingTest(SubjectEncodingTest):
201 subject = u'test s\xfcbject'
202 subject_header = 'test =?utf-8?q?s=c3=bcbject?='
204 class SenderCorrelationTest(TestCase):
205 existing_sender = 'Existing Sender <existing@example.com>'
206 non_existing_sender = 'Non-existing Sender <nonexisting@example.com>'
208 def mail(self, sender):
209 return message_from_string('From: %s\nSubject: Test\n\ntest\n' % sender)
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)
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)
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)
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)
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)
242 class MultipleProjectPatchTest(TestCase):
243 """ Test that patches sent to multiple patchwork projects are
244 handled correctly """
246 fixtures = ['default_states']
247 test_comment = 'Test Comment'
248 patch_filename = '0001-add-line.patch'
249 msgid = '<1@example.com>'
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')
260 patch = read_patch(self.patch_filename)
261 email = create_email(self.test_comment + '\n' + patch)
262 email['Message-Id'] = self.msgid
265 email['List-ID'] = '<' + self.p1.listid + '>'
269 email['List-ID'] = '<' + self.p2.listid + '>'
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)
281 class MultipleProjectPatchCommentTest(MultipleProjectPatchTest):
282 """ Test that followups to multiple-project patches end up on the
285 comment_msgid = '<2@example.com>'
286 comment_content = 'test comment'
289 super(MultipleProjectPatchCommentTest, self).setUp()
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
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)
307 class ListIdHeaderTest(TestCase):
308 """ Test that we parse List-Id headers from mails correctly """
310 self.project = Project(linkname = 'test-project-1', name = 'Project 1',
311 listid = '1.example.com', listemail='1@example.com')
314 def testNoListId(self):
316 project = find_project(email)
317 self.assertEquals(project, None)
319 def testBlankListId(self):
321 email['List-Id'] = ''
322 project = find_project(email)
323 self.assertEquals(project, None)
325 def testWhitespaceListId(self):
327 email['List-Id'] = ' '
328 project = find_project(email)
329 self.assertEquals(project, None)
331 def testSubstringListId(self):
333 email['List-Id'] = 'example.com'
334 project = find_project(email)
335 self.assertEquals(project, None)
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). """
341 email['List-Id'] = self.project.listid
342 project = find_project(email)
343 self.assertEquals(project, self.project)
345 def testLongListId(self):
347 email['List-Id'] = 'Test text <%s>' % self.project.listid
348 project = find_project(email)
349 self.assertEquals(project, self.project)
352 self.project.delete()
354 class MBoxPatchTest(PatchTest):
356 self.mail = read_mail(self.mail_file, project = self.project)
358 class GitPullTest(MBoxPatchTest):
359 mail_file = '0001-git-pull-request.mbox'
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)
368 class GitPullWrappedTest(GitPullTest):
369 mail_file = '0002-git-pull-request-wrapped.mbox'
371 class GitPullWithDiffTest(MBoxPatchTest):
372 mail_file = '0003-git-pull-request-with-diff.mbox'
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)
380 patch.content.startswith('diff --git a/arch/x86/include/asm/smp.h'),
382 self.assertTrue(comment is not None)
384 class GitPullGitSSHUrlTest(GitPullTest):
385 mail_file = '0004-git-pull-request-git+ssh.mbox'
387 class GitPullSSHUrlTest(GitPullTest):
388 mail_file = '0005-git-pull-request-ssh.mbox'
390 class GitPullHTTPUrlTest(GitPullTest):
391 mail_file = '0006-git-pull-request-http.mbox'
393 class GitRenameOnlyTest(MBoxPatchTest):
394 mail_file = '0008-git-rename.mbox'
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)
403 class GitRenameWithDiffTest(MBoxPatchTest):
404 mail_file = '0009-git-rename-with-diff.mbox'
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)
414 class CVSFormatPatchTest(MBoxPatchTest):
415 mail_file = '0007-cvs-format-diff.mbox'
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'))
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"""
427 mail_file = '0010-invalid-charset.mbox'
430 (patch, comment) = find_content(self.project, self.mail)
431 self.assertTrue(patch is not None)
432 self.assertTrue(comment is not None)
434 class NoNewlineAtEndOfFilePatchTest(MBoxPatchTest):
435 mail_file = '0011-no-newline-at-end-of-file.mbox'
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'))
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"
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')
463 email = create_email(self.patch)
465 email['List-ID'] = '<' + self.p1.listid + '>'
466 email['Message-Id'] = self.msgid
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)
474 def testDelegate(self):
475 email = self.get_email()
476 email['X-Patchwork-Delegate'] = self.user.email
478 self._assertDelegate(self.user)
480 def testNoDelegate(self):
481 email = self.get_email()
483 self._assertDelegate(None)
485 def testInvalidDelegateFallsBackToNoDelegate(self):
486 email = self.get_email()
487 email['X-Patchwork-Delegate'] = self.invalid_delegate_email
489 self._assertDelegate(None)
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"
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')
507 self.default_state = get_default_initial_patch_state()
508 self.nondefault_state = State.objects.get(name="Accepted")
511 email = create_email(self.patch)
513 email['List-ID'] = '<' + self.p1.listid + '>'
514 email['Message-Id'] = self.msgid
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)
522 def testNonDefaultStateIsActuallyNotTheDefaultState(self):
523 self.assertNotEqual(self.default_state, self.nondefault_state)
525 def testExplicitNonDefaultStateRequest(self):
526 email = self.get_email()
527 email['X-Patchwork-State'] = self.nondefault_state.name
529 self._assertState(self.nondefault_state)
531 def testExplicitDefaultStateRequest(self):
532 email = self.get_email()
533 email['X-Patchwork-State'] = self.default_state.name
535 self._assertState(self.default_state)
537 def testImplicitDefaultStateRequest(self):
538 email = self.get_email()
540 self._assertState(self.default_state)
542 def testInvalidTestStateDoesNotExist(self):
543 with self.assertRaises(State.DoesNotExist):
544 State.objects.get(name=self.invalid_state_name)
546 def testInvalidStateRequestFallsBackToDefaultState(self):
547 email = self.get_email()
548 email['X-Patchwork-State'] = self.invalid_state_name
550 self._assertState(self.default_state)
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']
564 project = defaults.project
565 project.listid = 'test.example.com'
567 self.orig_patch = read_patch(self.patch_filename)
568 email = create_email(self.test_comment + '\n' + self.orig_patch,
570 email['Message-Id'] = '<1@example.com>'
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)
583 class PrefixTest(TestCase):
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'])
594 class SubjectTest(TestCase):
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'),
606 self.assertEquals(clean_subject('[PATCH] [RFC] meep'),
608 self.assertEquals(clean_subject('[PATCH] [RFC,1/2] meep'),
610 self.assertEquals(clean_subject('[PATCH] [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']),
618 self.assertEquals(clean_subject('[FOO] [bar] meep', ['foo']),