def test_user_can_follow_users(self):
"""
Authenticated users should be able to follow other users.
"""
login(self.mr_foo)
response = self.follow('mr_baz')
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_article_without_violations_cannot_be_processed(self):
login(verified=True)
clean_article = self.generate_article(published=True)
login(admin=True)
response = self.process_violation(clean_article, 'approve')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn("This article does not have any pending violation reports.", response.data['error'])
def test_dislike_me_is_accurate(self):
login()
self.dislike(self.slug)
response = self.get_reactions(self.slug)
self.assertReactionsEqual(response.data['reactions'],
dislike_me=True,
dislike_count=1)
def test_user_cannot_follow_themselves(self):
"""
Users cannot follow themselves. It makes no logical sense. :)
"""
login(self.mr_foo)
response = self.follow('mr_foo')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('You cannot follow yourself.', response.data['errors'])
def test_owner_view_is_not_added_to_stats(self):
# owner logs in and views article
login(self.owner)
self.view_article(self.slug)
# owner gets stats
response = self.article_stats()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertStatsEqual(response.data, views=0)
def test_an_article_can_have_many_dislikes(self):
login()
self.dislike(self.slug) # first dislike
login()
response = self.dislike(self.slug) # second dislike
self.assertReactionsEqual(response.data['reactions'],
dislike_count=2,
dislike_me=True)
def test_users_cannot_report_an_article_more_than_once(self):
login(verified=True)
slug = self.generate_article(published=True)
login()
response = self.report(slug) # report for the first time
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = self.report(slug) # report for the second time
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn(b"You cannot report an article more than once.", response.content)
def test_user_cannot_un_follow_themselves(self):
"""
Users should be able to un-follow themselves. It does not make any logical sense.
"""
# let 'mr_foo' attempt to follow self
login(self.mr_foo)
response = self.un_follow('mr_foo')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('You cannot follow or un follow yourself.',
json.dumps(response.data))
def test_users_can_report_articles(self):
login(verified=True)
slug = self.generate_article(published=True)
login()
response = self.report(slug)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn(
b"Your report has been received. You will receive a confirmation email shortly.",
response.content
)
def test_only_one_view_is_added_per_user(self):
# other users view article
login()
self.view_article(self.slug)
self.view_article(self.slug)
# owner logs in
login(self.owner)
response = self.article_stats()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertStatsEqual(response.data, views=1)
def test_multiple_comments_by_same_user_are_added_to_stats(self):
# other users comment on article
login()
self.comment_on_article(self.slug)
self.comment_on_article(self.slug)
self.comment_on_article(self.slug)
# owner logs in
login(self.owner)
response = self.article_stats()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertStatsEqual(response.data, comments=3)
def test_user_can_un_follow_users(self):
"""
Authenticated users should be able to un-follow users they are currently following.
"""
# let 'mr_foo' follow then un-follow 'mr_baz'
login(self.mr_foo)
# follow
self.follow('mr_baz')
# un-follow
response = self.un_follow('mr_baz')
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_disliking_an_article_reverts_a_like_on_it(self):
login()
response = self.like(self.slug) # like
self.assertReactionsEqual(response.data['reactions'],
like_count=1,
like_me=True,
dislike_count=0,
dislike_me=False)
response = self.dislike(self.slug) # dislike
self.assertReactionsEqual(response.data['reactions'],
like_count=0,
like_me=False,
dislike_count=1,
dislike_me=True)
def test_user_can_see_following_list(self):
"""
Authenticated users can retrieve their following list.
"""
login(self.mr_foo)
# let 'mr_foo' follow both 'mr_bar' and 'mr_baz'
self.follow('mr_bar')
self.follow('mr_baz')
# retrieve mr_foo's following
response = self.following('mr_foo')
self.assertEqual(response.status_code, status.HTTP_200_OK)
# assert that 'mr_bar' and 'mr_baz' are on the following list
data = json.dumps(response.data)
self.assertIn('mr_bar', data)
self.assertIn('mr_baz', data)
def test_user_can_see_followers_list(self):
"""
Authenticated users can retrieve followers list.
"""
# let 'mr_bar' and 'mr_baz' follow 'mr_foo'
login(self.mr_bar)
self.follow('mr_foo')
login(self.mr_baz)
self.follow('mr_foo')
# retrieve mr_foo's followers
response = self.followers('mr_foo')
self.assertEqual(response.status_code, status.HTTP_200_OK)
# assert that 'mr_bar' and 'mr_baz' are on the followers list
data = json.dumps(response.data)
self.assertIn('mr_bar', data)
self.assertIn('mr_baz', data)
def setUp(self):
super().setUp()
set_test_client(self.client)
self.owner = login(verified=True)
self.article = self.create_article(published=True)
self.slug = self.article['slug']
logout()
def test_ratings_on_articles_are_added_to_stats(self):
# other users rate article
login()
self.rate_article(self.slug, 4)
login()
self.rate_article(self.slug, 2)
login()
self.rate_article(self.slug, 3)
# owner logs in - avg rating should be (4 + 2 + 3)/3 = 3
login(self.owner)
response = self.article_stats()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertStatsEqual(response.data, rating=3)
def test_views_by_different_users_are_added_to_stats(self):
# other users view article
login()
self.view_article(self.slug)
login()
self.view_article(self.slug)
login()
self.view_article(self.slug)
# owner logs in
login(self.owner)
response = self.article_stats()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertStatsEqual(response.data, views=3)
def test_dislikes_on_articles_are_added_to_stats(self):
# owner dislikes article
login(self.owner)
self.dislike_article(self.slug)
# other users rate article
login()
self.dislike_article(self.slug)
login()
self.dislike_article(self.slug)
# owner logs in
login(self.owner)
response = self.article_stats()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertStatsEqual(response.data, dislikes=3)
def test_like_count_is_accurate(self):
login()
self.like(self.slug)
login()
self.like(self.slug)
login()
response = self.get_reactions(self.slug)
self.assertReactionsEqual(response.data['reactions'], like_count=2)
def test_user_can_check_if_they_re_followed_by_others(self):
"""
Authenticated users can check whether they're being followed.
"""
# let 'mr_foo' check whether 'mr_bar' is following them
login(self.mr_foo)
response = self.is_following_me('mr_bar')
self.assertEqual(response.data, {"following_status": False})
# let 'mr_bar' follow 'mr_foo'
login(self.mr_bar)
self.follow('mr_foo')
# let 'mr_foo' check whether 'mr_bar' is following them
login(self.mr_foo)
response = self.is_following_me('mr_bar')
login(self.mr_bar)
response2 = self.is_following_me('mr_foo')
self.assertEqual(response.data, {"following_status": False})
self.assertEqual(response2.data, {"following_status": True})
def setUp(self):
super().setUp()
login(verified=True)
self.reported1 = self.generate_article(published=True)
self.reported2 = self.generate_article(published=True)
login()
self.report(self.reported1)
self.report(self.reported2)
login()
self.report(self.reported1)
self.report(self.reported2)
logout()
def test_admin_can_approve_article_violation_reports(self):
login(admin=True)
response = self.process_violation(self.reported1, 'approve')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertIn("You have approved this violation.", response.data['message'])
def test_users_cannot_report_non_existent_articles(self):
login(verified=True)
response = self.report('foo-bar')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_unauthenticated_users_cannot_report_articles(self):
login(verified=True)
slug = self.generate_article(published=True)
logout()
response = self.report(slug)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_users_cannot_report_their_own_articles(self):
login(verified=True)
slug = self.generate_article(published=True)
response = self.report(slug)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertIn(b"You cannot perform this action on your own article", response.content)
def test_user_can_see_violation_types(self):
login()
self.assertEqual(self.violation_types().data, Violation.represent_violation_types())
def test_ordinary_users_cannot_process_article_violation_reports(self):
login()
response = self.process_violation(self.reported1, 'reject')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
response = self.process_violation(self.reported1, 'approve')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_non_existent_article_cannot_be_processed(self):
login(admin=True)
response = self.process_violation('foobar', 'reject')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertIn("The article does not exist.", response.data['error'])
def test_invalid_decisions_are_not_allowed(self):
login(admin=True)
response = self.process_violation(self.reported1, 'foobar')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn("This violation decision 'foobar' is not valid.", response.data['error'])
