def test_cannot_delete_unavailable_comment(self):
"""
Test user cannot delete an unavailable comment
"""
slug = self.create_article()
url = API_Reverse('articles:comments', {slug: 'slug'})
url = API_Reverse('articles:comment-details', {slug: 'slug', 1: 'id'})
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_unauthenticated_user_cannot_delete_comment(self):
"""
Test non-owners of comments cannot delete comments
"""
slug = self.create_article()
url = API_Reverse('articles:comments', {slug: 'slug'})
response = self.client.post(url, self.comment, format='json')
id = response.data['id']
url = API_Reverse('articles:comment-details', {slug: 'slug', id: 'id'})
response = self.unauthorised_client.delete(url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_user_can_delete_comment(self):
"""
Test authenticated users can delete their comments
"""
slug = self.create_article()
url = API_Reverse('articles:comments', {slug: 'slug'})
response = self.client.post(url, self.comment, format='json')
id = response.data['id']
url = API_Reverse('articles:comment-details', {slug: 'slug', id: 'id'})
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_can_view_single_comment(self):
"""
Test users can view a single comment
"""
slug = self.create_article()
url = API_Reverse('articles:comments', {slug: 'slug'})
response = self.client.post(url, self.comment, format='json')
id = response.data['id']
url = API_Reverse('articles:comment-details', {slug: 'slug', id: 'id'})
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_can_thread_a_comment(self):
"""
Test users can thread a comment
"""
slug = self.create_article()
url = API_Reverse('articles:comments', {slug: 'slug'})
response = self.client.post(url, self.comment, format='json')
id = response.data['id']
url = API_Reverse('articles:comment-details', {slug: 'slug', id: 'id'})
response = self.client.post(
url, data={'comment': {
'body': 'child comment'
}}, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_comment_update_unavailable_comment(self):
"""
Test user cannot update an unavailable comment
"""
slug = self.create_article()
url = API_Reverse('articles:comments', {slug: 'slug'})
response = self.client.post(url, self.comment, format='json')
url = API_Reverse('articles:comment-details', {slug: 'slug', 1: 'id'})
response = self.client.put(url,
data={'comment': {
'body': 'New comment'
}},
format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_unauthorized_users_cannot_create_tags(self):
"""This method tests if unauthorized users can create tags"""
url = API_Reverse('articles:articles')
self.client.credentials(HTTP_AUTHORIZATION="")
response = self.client.post(url, data=self.article, format='json')
self.assertIn('Authentication credentials were not provided',
json.dumps(response.data))
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_user_can_get_all_tags(self):
"""This method tests if a user can get all tags"""
self.create_article()
url = API_Reverse('tags:tags')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn('test', json.dumps(response.data))
self.assertIn('tags', json.dumps(response.data))
def test_unauthenticated_user_cannot_comment(self):
"""
Test unauthenticated users cannot create comments
"""
# use a valid user to create article
slug = self.create_article()
url = API_Reverse('articles:comments', {slug: 'slug'})
response = self.unauthorised_client.post(url,
self.comment,
format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_user_can_delete(self):
"""This method tests if a user can delete articles"""
self.create_user()
self.activate_user()
token = self.login_user()
response = self.client.post(self.url,
self.article,
format='json',
HTTP_AUTHORIZATION=token)
slug = response.data['slug']
url = API_Reverse('articles:article-details', {slug: 'slug'})
r = self.client.delete(url, format='json', HTTP_AUTHORIZATION=token)
self.assertEqual(r.status_code, status.HTTP_200_OK)
self.assertIn("Article Deleted Successfully", json.dumps(r.data))
def test_cannot_update_comment_on_unavailable_article(self):
"""
Test user cannot update comment on an unavailable article
"""
self.create_user()
self.activate_user()
token = self.login_user()
self.client.credentials(HTTP_AUTHORIZATION=token)
url = API_Reverse('articles:comment-details', {
'slug': 'slug',
1: 'id'
})
response = self.client.put(url,
data={'comment': {
'body': 'New comment'
}},
format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def setUp(self):
"""This method sets up the tests"""
super().setUp()
self.reporter = {
"user": {
"username": "******",
"password": "******",
"email": "*****@*****.**"
}
}
self.reporter_token = self.create_and_login_user(user=self.reporter)
self.author_token = self.create_and_login_user(user=self.user)
self.article_slug = self.create_article(token=self.author_token)
self.report_url = API_Reverse(
'articles:report',
{self.article_slug: 'slug'}
)
self.report = {
"report": {
"report_msg": "I don't like this article because"
}
}
def test_user_can_update(self):
"""This method checks if a user can update an existing articles"""
self.create_user()
self.activate_user()
token = self.login_user()
response = self.client.post(self.url,
self.article,
format='json',
HTTP_AUTHORIZATION=token)
slug = response.data['slug']
url = API_Reverse('articles:article-details', {slug: 'slug'})
r = self.client.put(url,
data={
"article": {
"title": "Updated Title",
"body": "Updated body"
}
},
format='json',
HTTP_AUTHORIZATION=token)
self.assertIn("Updated Title", json.dumps(r.data))
self.assertEqual(r.status_code, status.HTTP_200_OK)
def create_comment(self):
slug = self.create_article()
url = API_Reverse('articles:comments', {slug: 'slug'})
response = self.client.post(url, self.comment, format='json')
return response, url
