def test_cant_retrieve_reported_and_approved_hashtag(self):
"""
should not be able to retrieve a reported and approved hashtag and return 403
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
hashtag = make_hashtag()
hashtag_name = hashtag.name
reporter = make_user()
report_category = make_moderation_category()
reporter.report_hashtag_with_name(hashtag_name=hashtag_name,
category_id=report_category.pk)
global_moderator = make_global_moderator()
moderated_object = ModeratedObject.get_or_create_moderated_object_for_hashtag(
hashtag=hashtag, category_id=report_category.pk)
global_moderator.approve_moderated_object(
moderated_object=moderated_object)
url = self._get_url(hashtag_name=hashtag_name)
response = self.client.get(url, **headers)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_can_retrieve_foreign_user_reported_hashtag(self):
"""
should be able to retrieve a foreign user reported hashtag and return 200
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
hashtag = make_hashtag()
hashtag_name = hashtag.name
reporter = make_user()
report_category = make_moderation_category()
reporter.report_hashtag_with_name(hashtag_name=hashtag_name,
category_id=report_category.pk)
url = self._get_url(hashtag_name=hashtag_name)
response = self.client.get(url, **headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
parsed_response = json.loads(response.content)
self.assertIn('name', parsed_response)
response_name = parsed_response['name']
self.assertEqual(response_name, hashtag_name)
def test_does_not_retrieve_encircled_post_with_hashtag(self):
"""
should not retrieve an encircled post with a givne hashtag and return 200
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
post_creator = make_user()
circle = make_circle(creator=post_creator)
hashtag = make_hashtag()
fake_post_text = make_fake_post_text(
) + ' and a little hashtag #%s' % hashtag.name
post_creator.create_encircled_post(circles_ids=[circle.pk],
text=fake_post_text)
url = self._get_url(hashtag_name=hashtag.name)
response = self.client.get(url, **headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
parsed_response = json.loads(response.content)
self.assertEqual(len(parsed_response), 0)
def test_does_not_retrieve_post_from_blocking_person_with_hashtag(self):
"""
should not retrieve a post from a blocking person with a given hashtag and return 200
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
post_creator = make_user()
hashtag = make_hashtag()
fake_post_text = make_fake_post_text(
) + ' and a little hashtag #%s' % hashtag.name
post_creator.create_public_post(text=fake_post_text)
post_creator.block_user_with_username(username=user.username)
url = self._get_url(hashtag_name=hashtag.name)
response = self.client.get(url, **headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
parsed_response = json.loads(response.content)
self.assertEqual(len(parsed_response), 0)
def test_retrieves_world_circle_post_with_hashtag(self):
"""
should retrieve world circle post with a given hashtag and return 200
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
post_creator = make_user()
hashtag = make_hashtag()
fake_post_text = make_fake_post_text(
) + ' and a little hashtag #%s' % hashtag.name
post_creator.create_public_post(text=fake_post_text)
url = self._get_url(hashtag_name=hashtag.name)
response = self.client.get(url, **headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
parsed_response = json.loads(response.content)
self.assertEqual(len(parsed_response), 1)
retrieved_posts = parsed_response[0]
self.assertEqual(retrieved_posts['text'], fake_post_text)
def test_does_not_retrieve_private_community_not_part_of_post_with_hashtag(
self):
"""
should not retrieve a private community not part of post with a givne hashtag and return 200
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
community_creator = make_user()
community = make_community(creator=community_creator,
type=Community.COMMUNITY_TYPE_PRIVATE)
post_creator = make_user()
community_creator.invite_user_with_username_to_community_with_name(
community_name=community.name, username=post_creator.username)
post_creator.join_community_with_name(community_name=community.name)
hashtag = make_hashtag()
fake_post_text = make_fake_post_text(
) + ' and a little hashtag #%s' % hashtag.name
post_creator.create_community_post(community_name=community.name,
text=fake_post_text)
url = self._get_url(hashtag_name=hashtag.name)
response = self.client.get(url, **headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
parsed_response = json.loads(response.content)
self.assertEqual(len(parsed_response), 0)
def test_can_retrieve_hashtag_with_posts_count(self):
"""
should be able to retrieve a hashtag with its posts count and return 200
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
hashtag = make_hashtag()
hashtag_name = hashtag.name
amount_of_posts = 3
for i in range(0, amount_of_posts):
user = make_user()
post_text = '#%s' % hashtag_name
user.create_public_post(text=post_text)
url = self._get_url(hashtag_name=hashtag_name)
response = self.client.get(url, **headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
parsed_response = json.loads(response.content)
self.assertIn('posts_count', parsed_response)
posts_count = parsed_response['posts_count']
self.assertEqual(posts_count, amount_of_posts)
def test_cant_search_for_reported_and_approved_hashtag(self):
"""
should not be able to search for a reported and approved hashtag and return 200
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
reporter = make_user()
hashtag_name = make_hashtag_name()
hashtag = make_hashtag(name=hashtag_name)
report_category = make_moderation_category()
reporter.report_hashtag_with_name(hashtag_name=hashtag_name,
category_id=report_category.pk)
global_moderator = make_global_moderator()
moderated_object = ModeratedObject.get_or_create_moderated_object_for_hashtag(
hashtag=hashtag, category_id=report_category.pk)
global_moderator.approve_moderated_object(
moderated_object=moderated_object)
url = self._get_url()
response = self.client.get(url, {'query': hashtag.name}, **headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
parsed_response = json.loads(response.content)
self.assertEqual(len(parsed_response), 0)
def test_can_search_hashtags_by_name(self):
"""
should be able to search for hashtags by their name and return 200
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
amount_of_hashtags_to_search_for = 5
for i in range(0, amount_of_hashtags_to_search_for):
hashtag_name = make_hashtag_name()
hashtag = make_hashtag(name=hashtag_name)
amount_of_characters_to_query = random.randint(
1, len(hashtag_name))
query = hashtag_name[0:amount_of_characters_to_query]
final_query = ''
for character in query:
final_query = final_query + (
character.upper() if fake.boolean() else character.lower())
url = self._get_url()
response = self.client.get(url, {'query': final_query}, **headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
parsed_response = json.loads(response.content)
self.assertEqual(len(parsed_response), 1)
retrieved_hashtag = parsed_response[0]
self.assertEqual(retrieved_hashtag['name'], hashtag_name.lower())
hashtag.delete()
def test_cant_retrieve_reported_hashtag(self):
"""
should not be able to retrieve a reported hashtag and return 403
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
hashtag = make_hashtag()
hashtag_name = hashtag.name
report_category = make_moderation_category()
user.report_hashtag_with_name(hashtag_name=hashtag_name,
category_id=report_category.pk)
url = self._get_url(hashtag_name=hashtag_name)
response = self.client.get(url, **headers)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_can_retrieve_hashtag(self):
"""
should be able to retrieve a hashtag and return 200
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
hashtag = make_hashtag()
hashtag_name = hashtag.name
url = self._get_url(hashtag_name=hashtag_name)
response = self.client.get(url, **headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
parsed_response = json.loads(response.content)
self.assertIn('name', parsed_response)
response_name = parsed_response['name']
self.assertEqual(response_name, hashtag_name)
def test_can_search_for_foreign_user_reported_hashtag(self):
"""
should be able to search for a foreign usre reported hashtag and return 200
"""
user = make_user()
headers = make_authentication_headers_for_user(user)
reporter = make_user()
hashtag_name = make_hashtag_name()
hashtag = make_hashtag(name=hashtag_name)
report_category = make_moderation_category()
reporter.report_hashtag_with_name(hashtag_name=hashtag_name,
category_id=report_category.pk)
url = self._get_url()
response = self.client.get(url, {'query': hashtag.name}, **headers)
self.assertEqual(response.status_code, status.HTTP_200_OK)
parsed_response = json.loads(response.content)
self.assertEqual(len(parsed_response), 1)
