def test_secondary_email_optin_form(self):
person = create_person(email=self.secondary_email, user=self.user)
EmailOptout(email=person.email).save()
form_re = self._form_re(reverse('mail-optin'), person.email)
response = self.client.get(reverse('user-profile'))
self.assertEqual(response.status_code, 200)
self.assertIsNotNone(form_re.search(response.content.decode()))
def test_create_duplicate_name(self):
newbundlename = 'testbundle-dup'
patch = self.patches[0]
params = {'form': 'patchlistform',
'bundle_name': newbundlename,
'action': 'Create',
'project': self.project.id,
'patch_id:%d' % patch.id: 'checked'}
response = self.client.post(
reverse('patch-list', kwargs={
'project_id': self.project.linkname}),
params)
n_bundles = Bundle.objects.count()
self.assertContains(response, 'Bundle %s created' % newbundlename)
self.assertContains(response, 'added to bundle %s' % newbundlename,
count=1)
bundle = Bundle.objects.get(name=newbundlename)
self.assertEqual(bundle.patches.count(), 1)
self.assertEqual(bundle.patches.all()[0], patch)
response = self.client.post(
reverse('patch-list', kwargs={
'project_id': self.project.linkname}),
params)
self.assertNotContains(response, 'Bundle %s created' % newbundlename)
self.assertContains(response, 'You already have a bundle called')
self.assertEqual(Bundle.objects.count(), n_bundles)
self.assertEqual(bundle.patches.count(), 1)
def test_redirects(self):
for view in ['help', 'help-about', 'help-pwclient']:
requested_url = reverse(view)
redirect_url = reverse('about')
response = self.client.get(requested_url)
self.assertRedirects(response, redirect_url, 301)
def test_redirects(self):
for view in ['help', 'help-about', 'help-pwclient']:
requested_url = reverse(view)
redirect_url = reverse('about')
response = self.client.get(requested_url)
self.assertRedirects(response, redirect_url, 301)
def render(self, context):
view_name = template.Variable('list_view.view').resolve(context)
kwargs = template.Variable('list_view.view_params').resolve(context)
path = None
try:
path = reverse(view_name, args=[], kwargs=kwargs)
except NoReverseMatch:
try:
project_name = settings.SETTINGS_MODULE.split('.')[0]
path = reverse(project_name + '.' + view_name,
args=[], kwargs=kwargs)
except NoReverseMatch:
raise
if path is None:
return ''
params = []
try:
qs_var = template.Variable('list_view.params').resolve(context)
params = dict(qs_var)
except (TypeError, template.VariableDoesNotExist):
pass
for (k, v) in self.params.items():
params[smart_str(k, 'ascii')] = v.resolve(context)
if not params:
return path
return path + '?' + '&'.join(
['%s=%s' % (k, escape(v)) for (k, v) in list(params.items())])
def test_secondary_email_optin_form(self):
person = create_person(email=self.secondary_email, user=self.user)
EmailOptout(email=person.email).save()
form_re = self._form_re(reverse('mail-optin'), person.email)
response = self.client.get(reverse('user-profile'))
self.assertEqual(response.status_code, 200)
self.assertIsNotNone(form_re.search(response.content.decode()))
def test_redirect(self):
cover_id = create_cover().id
requested_url = reverse('patch-detail', kwargs={'patch_id': cover_id})
redirect_url = reverse('cover-detail', kwargs={'cover_id': cover_id})
response = self.client.get(requested_url)
self.assertRedirects(response, redirect_url)
def test_xmlrpc(self):
with self.settings(ENABLE_XMLRPC=False):
response = self.client.get(reverse('about'))
self.assertFalse(response.context['enabled_apis']['xmlrpc'])
with self.settings(ENABLE_XMLRPC=True):
response = self.client.get(reverse('about'))
self.assertTrue(response.context['enabled_apis']['xmlrpc'])
def test_xmlrpc(self):
with self.settings(ENABLE_XMLRPC=False):
response = self.client.get(reverse('about'))
self.assertFalse(response.context['enabled_apis']['xmlrpc'])
with self.settings(ENABLE_XMLRPC=True):
response = self.client.get(reverse('about'))
self.assertTrue(response.context['enabled_apis']['xmlrpc'])
def test_post_optin(self):
email = u'*****@*****.**'
response = self.client.post(reverse('mail-settings'), {'email': email})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'patchwork/mail-settings.html')
self.assertEqual(response.context['is_optout'], False)
self.assertContains(response, '<strong>may</strong>')
self.assertContains(response, 'action="%s"' % reverse('mail-optout'))
def test_post_optin(self):
email = u'*****@*****.**'
response = self.client.post(reverse('mail-settings'), {'email': email})
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'patchwork/mail-settings.html')
self.assertEqual(response.context['is_optout'], False)
self.assertContains(response, '<strong>may</strong>')
self.assertContains(response, 'action="%s"' % reverse('mail-optout'))
def api_url(self, item=None):
if item is None:
return reverse('api-check-list', args=[self.patch.id])
return reverse('api-check-detail',
kwargs={
'patch_id': self.patch.id,
'check_id': item.id
})
def test_redirect(self):
project = utils.create_project()
requested_url = reverse('project-list')
redirect_url = reverse('patch-list', kwargs={
'project_id': project.linkname})
response = self.client.get(requested_url)
self.assertRedirects(response, redirect_url)
def test_redirect(self):
project = utils.create_project()
requested_url = reverse('project-list')
redirect_url = reverse('patch-list',
kwargs={'project_id': project.linkname})
response = self.client.get(requested_url)
self.assertRedirects(response, redirect_url)
def test_user_profile_todos(self):
patches = utils.create_patches(5)
for patch in patches:
patch.delegate = self.user
patch.save()
response = self.client.get(reverse('user-profile'))
self.assertContains(response, 'contains 5')
self.assertContains(response, reverse('user-todos'))
def _test_redirect(self, submission, submission_url, submission_id):
comment_id = create_comment(submission=submission).id
requested_url = reverse('comment-redirect',
kwargs={'comment_id': comment_id})
redirect_url = '%s#%d' % (reverse(
submission_url, kwargs={submission_id: submission.id}), comment_id)
response = self.client.get(requested_url)
self.assertRedirects(response, redirect_url)
def test_unlink_non_post(self):
secondary_email = _generate_secondary_email(self.user)
self._create_confirmation(secondary_email)
person = Person.objects.get(email=secondary_email)
response = self.client.get(reverse('user-unlink', args=[person.id]))
self.assertRedirects(response, reverse('user-profile'))
person = Person.objects.get(email=secondary_email)
self.assertEqual(person.user, self.user)
def test_rest(self):
# TODO(stephenfin): There appears to be a bug in Django 1.10.x under
# Python 3.5, meaning we can't use 'override_settings' here or we cause
# the REST API tests to fail. We should investigate this.
with self.settings(ENABLE_REST_API=False):
response = self.client.get(reverse('about'))
self.assertFalse(response.context['enabled_apis']['rest'])
with self.settings(ENABLE_REST_API=True):
response = self.client.get(reverse('about'))
self.assertTrue(response.context['enabled_apis']['rest'])
def test_rest(self):
# TODO(stephenfin): There appears to be a bug in Django 1.10.x under
# Python 3.5, meaning we can't use 'override_settings' here or we cause
# the REST API tests to fail. We should investigate this.
with self.settings(ENABLE_REST_API=False):
response = self.client.get(reverse('about'))
self.assertFalse(response.context['enabled_apis']['rest'])
with self.settings(ENABLE_REST_API=True):
response = self.client.get(reverse('about'))
self.assertTrue(response.context['enabled_apis']['rest'])
def test_series_dropdown(self):
patch = create_patch()
series = [create_series() for x in range(5)]
for series_ in series:
series_.add_patch(patch, 1)
response = self.client.get(
reverse('patch-detail', kwargs={'patch_id': patch.id}))
for series_ in series:
self.assertContains(
response,
reverse('series-mbox', kwargs={'series_id': series_.id}))
def test_login(self):
self.get(reverse('auth_login'))
self.enter_text('username', self.user.username)
self.enter_text('password', self.user.username)
self.click('input[value="Login"]')
dropdown = self.wait_until_visible('a.dropdown-toggle strong')
self.assertEqual(dropdown.text, self.user.username)
def _test_order(self, ids, expected_order):
newbundlename = 'testbundle-new'
# need to define our querystring explicity to enforce ordering
params = {'form': 'patchlistform',
'bundle_name': newbundlename,
'action': 'Create',
'project': self.project.id,
}
data = urlencode(params) + \
''.join(['&patch_id:%d=checked' % i for i in ids])
response = self.client.post(
reverse('patch-list', kwargs={
'project_id': self.project.linkname}),
data=data,
content_type='application/x-www-form-urlencoded',
)
self.assertContains(response, 'Bundle %s created' % newbundlename)
self.assertContains(response, 'added to bundle %s' % newbundlename,
count=5)
bundle = Bundle.objects.get(name=newbundlename)
# BundlePatches should be sorted by .order by default
bps = BundlePatch.objects.filter(bundle=bundle)
for (bp, p) in zip(bps, expected_order):
self.assertEqual(bp.patch.pk, p.pk)
bundle.delete()
def test_add_to_non_empty_bundle(self):
self.bundle.append_patch(self.patches[0])
patch = self.patches[1]
params = {'form': 'patchlistform',
'action': 'Add',
'project': self.project.id,
'bundle_id': self.bundle.id,
'patch_id:%d' % patch.id: 'checked'}
response = self.client.post(
reverse('patch-list', kwargs={
'project_id': self.project.linkname}),
params)
self.assertContains(response, 'added to bundle %s' % self.bundle.name,
count=1)
self.assertEqual(self.bundle.patches.count(), 2)
self.assertIn(self.patches[0], self.bundle.patches.all())
self.assertIn(self.patches[1], self.bundle.patches.all())
# check order
bps = [BundlePatch.objects.get(bundle=self.bundle,
patch=self.patches[i])
for i in [0, 1]]
self.assertTrue(bps[0].order < bps[1].order)
def test_name_complete(self):
people = [create_person(name='Test name'), create_person(name=None)]
response = self.client.get(reverse('api-submitters'), {'q': 'name'})
self.assertEqual(response.status_code, 200)
data = json.loads(response.content.decode())
self.assertEqual(len(data), 1)
self.assertEqual(data[0]['name'], people[0].name)
def test_login(self):
self.get(reverse('auth_login'))
self.enter_text('username', self.user.username)
self.enter_text('password', self.user.username)
self.click('input[value="Login"]')
dropdown = self.wait_until_visible('a.dropdown-toggle strong')
self.assertEqual(dropdown.text, self.user.username)
def test_post_non_email(self):
response = self.client.post(reverse('mail-optin'), {'email': 'foo'})
self.assertEqual(response.status_code, 200)
self.assertFormError(response, 'form', 'email', error_strings['email'])
self.assertTrue(response.context['error'])
self.assertNotIn('email_sent', response.context)
self.assertEqual(len(mail.outbox), 0)
def bundle_detail(request, username, bundlename):
bundle = get_object_or_404(Bundle, owner__username=username,
name=bundlename)
filter_settings = [(DelegateFilter, DelegateFilter.AnyDelegate)]
is_owner = request.user == bundle.owner
if not (is_owner or bundle.public):
return HttpResponseNotFound()
if is_owner:
if request.method == 'POST' and request.POST.get('form') == 'bundle':
action = request.POST.get('action', '').lower()
if action == 'delete':
bundle.delete()
return HttpResponseRedirect(reverse('user-profile'))
elif action == 'update':
form = BundleForm(request.POST, instance=bundle)
if form.is_valid():
form.save()
# if we've changed the bundle name, redirect to new URL
bundle = Bundle.objects.get(pk=bundle.pk)
if bundle.name != bundlename:
return HttpResponseRedirect(bundle.get_absolute_url())
else:
form = BundleForm(instance=bundle)
else:
form = BundleForm(instance=bundle)
if (request.method == 'POST' and
request.POST.get('form') == 'reorderform'):
order = get_object_or_404(
BundlePatch,
bundle=bundle,
patch__id=request.POST.get('order_start')).order
for patch_id in request.POST.getlist('neworder'):
bundlepatch = get_object_or_404(BundlePatch,
bundle=bundle,
patch__id=patch_id)
bundlepatch.order = order
bundlepatch.save()
order += 1
else:
form = None
context = generic_list(request, bundle.project,
'bundle-detail',
view_args={'username': bundle.owner.username,
'bundlename': bundle.name},
filter_settings=filter_settings,
patches=bundle.ordered_patches(),
editable_order=is_owner)
context['bundle'] = bundle
context['bundleform'] = form
return render(request, 'patchwork/bundle.html', context)
def bundle_mbox_redir(request, bundle_id):
bundle = get_object_or_404(Bundle, id=bundle_id, owner=request.user)
return HttpResponseRedirect(
reverse('bundle-mbox', kwargs={
'username': request.user.username,
'bundlename': bundle.name,
}))
def test_post_non_email(self):
response = self.client.post(reverse('mail-optin'), {'email': 'foo'})
self.assertEqual(response.status_code, 200)
self.assertFormError(response, 'form', 'email', error_strings['email'])
self.assertTrue(response.context['error'])
self.assertNotIn('email_sent', response.context)
self.assertEqual(len(mail.outbox), 0)
def test_name_complete(self):
people = [create_person(name='Test name'), create_person(name=None)]
response = self.client.get(reverse('api-submitters'), {'q': 'name'})
self.assertEqual(response.status_code, 200)
data = json.loads(response.content.decode())
self.assertEqual(len(data), 1)
self.assertEqual(data[0]['name'], people[0].name)
def test_post_empty(self):
response = self.client.post(reverse('mail-optin'), {'email': ''})
self.assertEqual(response.status_code, 200)
self.assertFormError(response, 'form', 'email',
'This field is required.')
self.assertTrue(response.context['error'])
self.assertNotIn('email_sent', response.context)
self.assertEqual(len(mail.outbox), 0)
def test_opt_in_without_optout(self):
email = u'*****@*****.**'
response = self.client.post(reverse('mail-optin'), {'email': email})
# check for an error message
self.assertEqual(response.status_code, 200)
self.assertTrue(bool(response.context['error']))
self.assertContains(response, 'not on the patchwork opt-out list')
def unlink(request, person_id):
person = get_object_or_404(Person, id=person_id)
if request.method == 'POST' and person.email != request.user.email:
person.user = None
person.save()
return HttpResponseRedirect(reverse('user-profile'))
def unlink(request, person_id):
person = get_object_or_404(Person, id=person_id)
if request.method == 'POST' and person.email != request.user.email:
person.user = None
person.save()
return HttpResponseRedirect(reverse('user-profile'))
def test_opt_in_without_optout(self):
email = u'*****@*****.**'
response = self.client.post(reverse('mail-optin'), {'email': email})
# check for an error message
self.assertEqual(response.status_code, 200)
self.assertTrue(bool(response.context['error']))
self.assertContains(response, 'not on the patchwork opt-out list')
def test_post_empty(self):
response = self.client.post(reverse('mail-optin'), {'email': ''})
self.assertEqual(response.status_code, 200)
self.assertFormError(response, 'form', 'email',
'This field is required.')
self.assertTrue(response.context['error'])
self.assertNotIn('email_sent', response.context)
self.assertEqual(len(mail.outbox), 0)
def test_utf8_handling(self):
"""Validate handling of non-ascii characters."""
project = create_project()
url = reverse('patch-list', args=[project.linkname])
response = self.client.get(url + '?submitter=%%E2%%98%%83')
self.assertEqual(response.status_code, 200)
def test_param_limit(self):
for i in range(10):
create_person()
response = self.client.get(reverse('api-submitters'),
{'q': 'test', 'l': 5})
self.assertEqual(response.status_code, 200)
data = json.loads(response.content.decode())
self.assertEqual(len(data), 5)
def test_email_complete(self):
people = [create_person(email='*****@*****.**'),
create_person(email='*****@*****.**')]
response = self.client.get(reverse('api-submitters'), {'q': 'test2'})
self.assertEqual(response.status_code, 200)
data = json.loads(response.content.decode())
self.assertEqual(len(data), 1)
self.assertEqual(data[0]['email'], people[1].email)
def test_user_profile_bundles(self):
bundle = create_bundle(owner=self.user)
response = self.client.get(reverse('user-profile'))
self.assertContains(response, 'Your Profile')
self.assertContains(response, 'You have the following bundle')
self.assertContains(response, bundle.get_absolute_url())
def bundle_mbox_redir(request, bundle_id):
bundle = get_object_or_404(Bundle, id=bundle_id, owner=request.user)
return HttpResponseRedirect(
reverse('bundle-mbox',
kwargs={
'username': request.user.username,
'bundlename': bundle.name,
}))
def test_no_redirect(self):
utils.create_project()
utils.create_project()
requested_url = reverse('project-list')
response = self.client.get(requested_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.context['projects']), 2)
def setUp(self):
self.url = self.live_server_url + reverse('xmlrpc')
# url is of the form http://localhost:PORT/PATH
# strip the http and replace it with the username/passwd of a user.
self.project = utils.create_project()
self.user = utils.create_maintainer(self.project)
self.url = ('http://%s:%s@' + self.url[7:]) % (self.user.username,
self.user.username)
self.rpc = xmlrpc_client.Server(self.url)
def test_date_order(self):
url = reverse('patch-list',
kwargs={'project_id': self.project.linkname})
response = self.client.get(url + '?order=date')
def test_fn(p1, p2):
self.assertLessEqual(p1.date, p2.date)
self._test_sequence(response, test_fn)
def test_user_profile_invalid_post(self):
user_profile = UserProfile.objects.get(user=self.user.id)
old_ppp = user_profile.items_per_page
new_ppp = -1
self.client.post(reverse('user-profile'), {'items_per_page': new_ppp})
user_profile = UserProfile.objects.get(user=self.user.id)
self.assertEqual(user_profile.items_per_page, old_ppp)
def test_no_redirect(self):
utils.create_project()
utils.create_project()
requested_url = reverse('project-list')
response = self.client.get(requested_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.context['projects']), 2)
def test_date_header(self):
patch = create_patch()
response = self.client.get(reverse('patch-mbox', args=[patch.id]))
mail = email.message_from_string(response.content.decode())
mail_date = dateutil.parser.parse(mail['Date'])
# patch dates are all in UTC
patch_date = patch.date.replace(tzinfo=dateutil.tz.tzutc(),
microsecond=0)
self.assertEqual(mail_date, patch_date)
def test_date_order(self):
url = reverse('patch-list',
kwargs={'project_id': self.project.linkname})
response = self.client.get(url + '?order=date')
def test_fn(p1, p2):
self.assertLessEqual(p1.date, p2.date)
self._test_sequence(response, test_fn)
def setUp(self):
self.url = self.live_server_url + reverse('xmlrpc')
# url is of the form http://localhost:PORT/PATH
# strip the http and replace it with the username/passwd of a user.
self.project = utils.create_project()
self.user = utils.create_maintainer(self.project)
self.url = ('http://%s:%s@' + self.url[7:]) % (self.user.username,
self.user.username)
self.rpc = xmlrpc_client.Server(self.url)
def test_date_header(self):
patch = create_patch()
response = self.client.get(reverse('patch-mbox', args=[patch.id]))
mail = email.message_from_string(response.content.decode())
mail_date = dateutil.parser.parse(mail['Date'])
# patch dates are all in UTC
patch_date = patch.date.replace(tzinfo=dateutil.tz.tzutc(),
microsecond=0)
self.assertEqual(mail_date, patch_date)
def test_post(self):
email = u'*****@*****.**'
response = self.client.post(reverse('mail-optout'), {'email': email})
# check for a confirmation object
self.assertEqual(EmailConfirmation.objects.count(), 1)
conf = EmailConfirmation.objects.get(email=email)
# check confirmation page
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['confirmation'], conf)
self.assertContains(response, email)
# check email
self.assertEqual(len(mail.outbox), 1)
msg = mail.outbox[0]
self.assertEqual(msg.to, [email])
self.assertEqual(msg.subject, 'Patchwork opt-out confirmation')
self.assertIn(reverse('confirm', kwargs={'key': conf.key}), msg.body)
def test_submitter_reverse_order(self):
url = reverse('patch-list',
kwargs={'project_id': self.project.linkname})
response = self.client.get(url + '?order=-submitter')
def test_fn(p1, p2):
self.assertGreaterEqual(p1.submitter.name.lower(),
p2.submitter.name.lower())
self._test_sequence(response, test_fn)
def test_patchwork_from_header(self):
"""Validate inclusion of generated 'X-Patchwork-From' header."""
email = '*****@*****.**'
from_header = 'From: Jon Doe <%s>\n' % email
person = create_person(name='Jonathon Doe', email=email)
patch = create_patch(submitter=person, headers=from_header)
response = self.client.get(reverse('patch-mbox', args=[patch.id]))
self.assertContains(response, from_header)
self.assertContains(response, 'X-Patchwork-Submitter: %s <%s>' % (
person.name, email))
def test_patch_response(self):
patch = create_patch(
project=self.project,
submitter=self.person,
content='comment 1 text\nAcked-by: 1\n')
create_comment(
submission=patch,
submitter=self.person,
content='comment 2 text\nAcked-by: 2\n')
response = self.client.get(reverse('patch-mbox', args=[patch.id]))
self.assertContains(response, 'Acked-by: 1\nAcked-by: 2\n')
def test_patch_utf8_nbsp(self):
patch = create_patch(
project=self.project,
submitter=self.person,
content='patch text\n')
create_comment(
submission=patch,
submitter=self.person,
content=u'comment\nAcked-by:\u00A0 foo')
response = self.client.get(reverse('patch-mbox', args=[patch.id]))
self.assertContains(response, u'\u00A0 foo\n')
def comment(request, comment_id):
submission = shortcuts.get_object_or_404(models.Comment,
id=comment_id).submission
if models.Patch.objects.filter(id=submission.id).exists():
url = 'patch-detail'
key = 'patch_id'
else:
url = 'cover-detail'
key = 'cover_id'
return http.HttpResponseRedirect('%s#%s' % (
reverse(url, kwargs={key: submission.id}), comment_id))
def test_from_header(self):
"""Validate non-ascii 'From' header.
Test that a person with characters outside ASCII in his name do
produce correct From header. As RFC 2822 state we must retain
the <*****@*****.**> format for the mail while the name part
may be coded in some ways.
"""
person = create_person(name=u'©ool guŷ')
patch = create_patch(submitter=person)
from_email = '<' + person.email + '>'
response = self.client.get(reverse('patch-mbox', args=[patch.id]))
self.assertContains(response, from_email)
def personify(person, project):
if person.name:
linktext = escape(person.name)
else:
linktext = escape(person.email)
url = reverse('patch-list',
kwargs={'project_id': project.linkname})
out = '<a href="%s?%s=%s">%s</a>' % (
url, SubmitterFilter.param, escape(person.id), linktext)
return mark_safe(out)
