def test_detail(self):
"""Validate we can get a specific series."""
series = create_series()
create_cover(series=series)
resp = self.client.get(self.api_url(series.id))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertSerialized(series, resp.data)
def _create_series(self):
project_obj = create_project(linkname='myproject')
person_obj = create_person(email='*****@*****.**')
series_obj = create_series(project=project_obj, submitter=person_obj)
create_cover(series=series_obj)
create_patch(series=series_obj)
return series_obj
def test_list_version_1_0(self):
create_cover()
resp = self.client.get(self.api_url(version='1.0'))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
self.assertIn('url', resp.data[0])
self.assertNotIn('mbox', resp.data[0])
self.assertNotIn('web_url', resp.data[0])
def test_detail_version_1_0(self):
cover = create_cover()
resp = self.client.get(self.api_url(cover.id, version='1.0'))
self.assertIn('url', resp.data)
self.assertNotIn('web_url', resp.data)
self.assertNotIn('comments', resp.data)
def test_cover_created(self):
cover = utils.create_cover()
events = _get_events(cover=cover)
self.assertEqual(events.count(), 1)
self.assertEqual(events[0].category, Event.CATEGORY_COVER_CREATED)
self.assertEqual(events[0].project, cover.project)
self.assertEventFields(events[0])
def test_detail(self):
"""Validate we can get a specific cover letter."""
cover_obj = create_cover()
resp = self.client.get(self.api_url(cover_obj.id))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertSerialized(cover_obj, resp.data)
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_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_list_version_1_0(self):
"""List cover letter comments using API v1.0."""
cover = create_cover()
create_comment(submission=cover)
# check we can't access comments using the old version of the API
with self.assertRaises(NoReverseMatch):
self.client.get(self.api_url(cover, version='1.0'))
def test_list(self):
"""List cover letter comments."""
cover = create_cover()
comment = create_comment(submission=cover)
resp = self.client.get(self.api_url(cover))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
self.assertSerialized(comment, resp.data[0])
def test_find_cover_for_comment__direct_reply(self):
"""Test behavior when we have a reference to the original cover."""
msgid = make_msgid()
project = create_project()
cover = create_cover(msgid=msgid, project=project)
result = parser.find_cover_for_comment(project, [msgid])
self.assertEqual(cover, result)
def test_detail(self):
"""Validate we can get a specific series."""
cover = create_cover()
series = create_series()
series.add_cover_letter(cover)
resp = self.client.get(self.api_url(series.id))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertSerialized(series, resp.data)
def test_list_filter_project(self):
"""Filter cover letters by project."""
cover = create_cover()
project = cover.project
resp = self.client.get(self.api_url(), {'project': project.linkname})
self.assertEqual([cover.id], [x['id'] for x in resp.data])
resp = self.client.get(self.api_url(), {'project': 'invalidproject'})
self.assertEqual(0, len(resp.data))
def test_find_cover_for_comment__indirect_reply(self):
"""Test behavior when we only have a reference to a comment."""
msgid = make_msgid()
project = create_project()
cover = create_cover(project=project)
create_cover_comment(cover=cover, msgid=msgid)
result = parser.find_cover_for_comment(project, [msgid])
self.assertEqual(cover, result)
def test_list_authenticated(self):
"""List cover letters as an authenticated user."""
cover = create_cover()
user = create_user()
self.client.force_authenticate(user=user)
resp = self.client.get(self.api_url())
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
self.assertSerialized(cover, resp.data[0])
def test_list_version_1_1(self):
"""List cover letter comments using API v1.1."""
cover = create_cover()
comment = create_cover_comment(cover=cover)
resp = self.client.get(self.api_url(cover, version='1.1'))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
self.assertSerialized(comment, resp.data[0])
self.assertNotIn('list_archive_url', resp.data[0])
def test_list(self):
"""Validate we can list series."""
resp = self.client.get(self.api_url())
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(0, len(resp.data))
project_obj = create_project(linkname='myproject')
person_obj = create_person(email='*****@*****.**')
series_obj = create_series(project=project_obj, submitter=person_obj)
create_cover(series=series_obj)
create_patch(series=series_obj)
# anonymous users
resp = self.client.get(self.api_url())
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
series_rsp = resp.data[0]
self.assertSerialized(series_obj, series_rsp)
# authenticated user
user = create_user()
self.client.force_authenticate(user=user)
resp = self.client.get(self.api_url())
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
series_rsp = resp.data[0]
self.assertSerialized(series_obj, series_rsp)
# test filtering by project
resp = self.client.get(self.api_url(), {'project': 'myproject'})
self.assertEqual([series_obj.id], [x['id'] for x in resp.data])
resp = self.client.get(self.api_url(), {'project': 'invalidproject'})
self.assertEqual(0, len(resp.data))
# test filtering by owner, both ID and email
resp = self.client.get(self.api_url(), {'submitter': person_obj.id})
self.assertEqual([series_obj.id], [x['id'] for x in resp.data])
resp = self.client.get(self.api_url(), {
'submitter': '*****@*****.**'})
self.assertEqual([series_obj.id], [x['id'] for x in resp.data])
resp = self.client.get(self.api_url(), {
'submitter': '*****@*****.**'})
self.assertEqual(0, len(resp.data))
def test_list_anonymous(self):
"""List cover letter as anonymous user."""
# we specifically set series to None to test code that handles legacy
# cover letters created before series existed
cover = create_cover(series=None)
resp = self.client.get(self.api_url())
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
self.assertSerialized(cover, resp.data[0])
def test_list_authenticated(self):
"""List cover letters as an authenticated user."""
cover = create_cover()
user = create_user()
self.client.force_authenticate(user=user)
resp = self.client.get(self.api_url())
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
self.assertSerialized(cover, resp.data[0])
def test_list_filter_project(self):
"""Filter cover letters by project."""
cover = create_cover()
project = cover.project
resp = self.client.get(self.api_url(), {'project': project.linkname})
self.assertEqual([cover.id], [x['id'] for x in resp.data])
resp = self.client.get(self.api_url(), {'project': 'invalidproject'})
self.assertEqual(0, len(resp.data))
def test_list_anonymous(self):
"""List cover letter as anonymous user."""
# we specifically set series to None to test code that handles legacy
# cover letters created before series existed
cover = create_cover(series=None)
resp = self.client.get(self.api_url())
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
self.assertSerialized(cover, resp.data[0])
def test_list_filter_msgid(self):
"""Filter covers by msgid."""
cover = create_cover()
resp = self.client.get(self.api_url(), {'msgid': cover.url_msgid})
self.assertEqual([cover.id], [x['id'] for x in resp.data])
# empty response if nothing matches
resp = self.client.get(self.api_url(), {'msgid': '*****@*****.**'})
self.assertEqual(0, len(resp.data))
def test_old_mbox_url(self):
cover = create_cover()
requested_url = reverse('cover-mbox-redirect',
kwargs={'cover_id': cover.id})
redirect_url = reverse('cover-mbox',
kwargs={'project_id': cover.project.linkname,
'msgid': cover.url_msgid})
response = self.client.get(requested_url)
self.assertRedirects(response, redirect_url)
def test_redirect(self):
cover = create_cover()
requested_url = reverse('patch-detail',
kwargs={'project_id': cover.project.linkname,
'msgid': cover.url_msgid})
redirect_url = reverse('cover-detail',
kwargs={'project_id': cover.project.linkname,
'msgid': cover.url_msgid})
response = self.client.get(requested_url)
self.assertRedirects(response, redirect_url)
def test_update_invalid_addressed(self):
"""Update an existing cover letter comment using invalid values.
Ensure we handle invalid cover letter comment addressed values.
"""
person = create_person(name='cover-submitter', user=create_user())
cover = create_cover(submitter=person)
resp = self._test_update(person=person,
cover=cover,
addressed='not-valid',
validate_request=False)
self.assertEqual(status.HTTP_400_BAD_REQUEST, resp.status_code)
self.assertFalse(
getattr(CoverComment.objects.all().first(), 'addressed'))
def _create_events(self):
"""Create sample events.
This one's a bit weird. While we could generate event models ourselves,
it seems wiser to test the event machinery as many times as possible.
As a result, we actually create a load of *other* objects, which will
raise signals and trigger the remainder.
"""
# series-created
series = create_series()
# patch-created, patch-completed, series-completed
patch = create_patch(series=series)
# cover-created
create_cover(series=series)
# check-created
create_check(patch=patch)
# patch-delegated, patch-state-changed
user = create_maintainer(project=patch.project)
state = create_state()
patch.delegate = user
patch.state = state
patch.save()
return Event.objects.all()
def test_cover_redirect(self):
cover = create_cover()
comment_id = create_cover_comment(cover=cover).id
requested_url = reverse('comment-redirect',
kwargs={'comment_id': comment_id})
redirect_url = '%s#%d' % (reverse('cover-detail',
kwargs={
'project_id':
cover.project.linkname,
'msgid': cover.url_msgid
}), comment_id)
response = self.client.get(requested_url)
self.assertRedirects(response, redirect_url)
def test_detail(self):
"""Validate we can get a specific cover letter."""
cover_obj = create_cover(
headers='Received: from somewhere\nReceived: from another place')
resp = self.client.get(self.api_url(cover_obj.id))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertSerialized(cover_obj, resp.data)
# Make sure we don't regress and all headers with the same key are
# included in the response
parsed_headers = email.parser.Parser().parsestr(
cover_obj.headers, True)
for key, value in parsed_headers.items():
self.assertIn(value, resp.data['headers'][key])
def test_list_filter_submitter(self):
"""Filter cover letter by submitter."""
cover = create_cover()
submitter = cover.submitter
# test filtering by submitter, both ID and email
resp = self.client.get(self.api_url(), {'submitter': submitter.id})
self.assertEqual([cover.id], [x['id'] for x in resp.data])
resp = self.client.get(self.api_url(), {'submitter': submitter.email})
self.assertEqual([cover.id], [x['id'] for x in resp.data])
resp = self.client.get(self.api_url(),
{'submitter': '*****@*****.**'})
self.assertEqual(0, len(resp.data))
def test_list_filter_submitter(self):
"""Filter cover letter by submitter."""
cover = create_cover()
submitter = cover.submitter
# test filtering by submitter, both ID and email
resp = self.client.get(self.api_url(), {'submitter': submitter.id})
self.assertEqual([cover.id], [x['id'] for x in resp.data])
resp = self.client.get(self.api_url(), {
'submitter': submitter.email})
self.assertEqual([cover.id], [x['id'] for x in resp.data])
resp = self.client.get(self.api_url(), {
'submitter': '*****@*****.**'})
self.assertEqual(0, len(resp.data))
def test_detail(self):
"""Validate we can get a specific cover letter."""
cover_obj = create_cover(
headers='Received: from somewhere\nReceived: from another place'
)
resp = self.client.get(self.api_url(cover_obj.id))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertSerialized(cover_obj, resp.data)
# Make sure we don't regress and all headers with the same key are
# included in the response
parsed_headers = email.parser.Parser().parsestr(cover_obj.headers,
True)
for key, value in parsed_headers.items():
self.assertIn(value, resp.data['headers'][key])
def test_detail(self):
"""Validate we can get a specific series."""
series = create_series()
resp = self.client.get(self.api_url(series.id))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertSerialized(series, resp.data)
patch = create_patch(project=series.project)
series.add_patch(patch, 1)
resp = self.client.get(self.api_url(series.id))
self.assertSerialized(series, resp.data)
cover_letter = create_cover(project=series.project)
series.add_cover_letter(cover_letter)
resp = self.client.get(self.api_url(series.id))
self.assertSerialized(series, resp.data)
def test_list(self):
cover_obj = create_cover()
resp = self.client.get(self.api_url(cover_obj))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(0, len(resp.data))
comment_obj = create_comment(submission=cover_obj)
resp = self.client.get(self.api_url(cover_obj))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
self.assertSerialized(comment_obj, resp.data[0])
create_comment(submission=cover_obj)
resp = self.client.get(self.api_url(cover_obj))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(2, len(resp.data))
# check we can't access comments using the old version of the API
with self.assertRaises(NoReverseMatch):
self.client.get(self.api_url(cover_obj, version='1.0'))
def test_list(self):
cover_obj = create_cover()
resp = self.client.get(self.api_url(cover_obj))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(0, len(resp.data))
comment_obj = create_comment(submission=cover_obj)
resp = self.client.get(self.api_url(cover_obj))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
self.assertSerialized(comment_obj, resp.data[0])
create_comment(submission=cover_obj)
resp = self.client.get(self.api_url(cover_obj))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(2, len(resp.data))
# check we can't access comments using the old version of the API
with self.assertRaises(NoReverseMatch):
self.client.get(self.api_url(cover_obj, version='1.0'))
def test_list(self):
"""Validate we can list cover letters."""
resp = self.client.get(self.api_url())
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(0, len(resp.data))
cover_obj = create_cover()
# anonymous user
resp = self.client.get(self.api_url())
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
self.assertSerialized(cover_obj, resp.data[0])
# authenticated user
user = create_user()
self.client.force_authenticate(user=user)
resp = self.client.get(self.api_url())
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(1, len(resp.data))
self.assertSerialized(cover_obj, resp.data[0])
def test_cover_redirect(self):
cover = create_cover()
self._test_redirect(cover, "cover-detail", "cover_id")
def setUp(self):
super(TestCoverComments, self).setUp()
self.project = create_project()
self.user = create_maintainer(self.project)
self.cover = create_cover(project=self.project)
def test_cover_redirect(self):
cover = create_cover()
self._test_redirect(cover, 'cover-detail')
def test_list_empty(self):
"""List cover letter comments when none are present."""
cover = create_cover()
resp = self.client.get(self.api_url(cover))
self.assertEqual(status.HTTP_200_OK, resp.status_code)
self.assertEqual(0, len(resp.data))
def test_cover_redirect(self):
cover = create_cover()
self._test_redirect(cover, 'cover-detail', 'cover_id')
