def test_follow(self):
url = FOLLOW_URL.format(self.alex.id)
# need to login to follow others
response = self.anonymous_client.post(url)
self.assertEqual(response.status_code, 403)
# need to use post to follow
response = self.bob_client.get(url)
self.assertEqual(response.status_code, 405)
# you cannot follow yourself
response = self.alex_client.post(url)
self.assertEqual(response.status_code, 400)
# successful follow
response = self.bob_client.post(url)
self.assertEqual(response.status_code, 201)
# self.assertEqual('user' in response.data, True)
self.assertEqual('created_at' in response.data, True)
self.assertEqual(response.data['user']['id'], self.alex.id)
self.assertEqual(response.data['user']['username'], self.alex.username)
# duplicate follow silent process
response = self.bob_client.post(url)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data['duplicate'], True)
# follow back will create new records
before_count = FriendshipService.get_following_count(self.alex.id)
response = self.alex_client.post(FOLLOW_URL.format(self.bob.id))
self.assertEqual(response.status_code, 201)
after_count = FriendshipService.get_following_count(self.alex.id)
self.assertEqual(after_count, before_count + 1)
def test_unfollow(self):
url = UNFOLLOW_URL.format(self.alex.id)
# need to login to unfollow others
response = self.anonymous_client.post(url)
self.assertEqual(response.status_code, 403)
# need to use post to unfollow
response = self.bob_client.get(url)
self.assertEqual(response.status_code, 405)
# you cannot unfollow yourself
response = self.alex_client.post(url)
self.assertEqual(response.status_code, 400)
# successful unfollow
self.create_friendship(from_user=self.bob, to_user=self.alex)
before_count = FriendshipService.get_following_count(self.bob.id)
response = self.bob_client.post(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['deleted'], 1)
after_count = FriendshipService.get_following_count(self.bob.id)
self.assertEqual(after_count, before_count - 1)
# unfollow a person that you haven't followed, silent process
before_count = FriendshipService.get_following_count(self.alex.id)
response = self.bob_client.post(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['deleted'], 0)
after_count = FriendshipService.get_following_count(self.alex.id)
self.assertEqual(before_count, after_count)
def _test_follow(self):
self._create_dummy_friendship()
# only allow POST method
response = self.user2_client.get(FOLLOW_URL.format(self.user3.id))
self.assertEqual(response.status_code, 405)
# anonymous client not allowed
response = self.anonymous_client.post(FOLLOW_URL.format(self.user3.id))
self.assertEqual(response.status_code, 403)
# follow non-existed user
# user_id 999 not exists
response = self.user2_client.post(FOLLOW_URL.format(999))
self.assertEqual(response.status_code, 404)
# not support follow myself
response = self.user2_client.post(FOLLOW_URL.format(self.user2.id))
self.assertEqual(response.status_code, 201)
# follow
before_count = FriendshipService.get_following_count(self.user2.id)
response = self.user2_client.post(FOLLOW_URL.format(self.user3.id))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['success'], True)
self.assertEqual(response.data['friendship']['from_user_id'],
self.user2.id)
self.assertEqual(response.data['friendship']['to_user_id'],
self.user3.id)
after_count = FriendshipService.get_following_count(self.user2.id)
self.assertEqual(before_count + 1, after_count)
# re-follow throws error
before_count = FriendshipService.get_following_count(self.user2.id)
response = self.user2_client.post(FOLLOW_URL.format(self.user3.id))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['success'], True)
self.assertEqual(response.data['duplicated'], True)
after_count = FriendshipService.get_following_count(self.user2.id)
self.assertEqual(before_count, after_count)
def _test_unfollow(self):
self._create_dummy_friendship()
# only allow POST method
response = self.user2_client.get(UNFOLLOW_URL.format(self.user3.id))
self.assertEqual(response.status_code, 405)
# anonymous client not allowed
response = self.anonymous_client.post(
UNFOLLOW_URL.format(self.user3.id))
self.assertEqual(response.status_code, 403)
# unfollow non-existed user, user_id 999 not exists
response = self.user2_client.post(UNFOLLOW_URL.format(999))
self.assertEqual(response.status_code, 404)
# not support unfollow myself
response = self.user2_client.post(UNFOLLOW_URL.format(self.user2.id))
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data['success'], False)
self.assertEqual(response.data['message'],
"You cannot unfollow yourself.")
# unfollow
before_count = FriendshipService.get_following_count(self.user2.id)
response = self.user2_client.post(UNFOLLOW_URL.format(self.user1.id))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['success'], True)
self.assertEqual(int(response.data['deleted']), 1)
after_count = FriendshipService.get_following_count(self.user2.id)
self.assertEqual(before_count - 1, after_count)
# re-unfollow
before_count = FriendshipService.get_following_count(self.user2.id)
response = self.user2_client.post(UNFOLLOW_URL.format(self.user1.id))
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data, 'Friendship not exists')
after_count = FriendshipService.get_following_count(self.user2.id)
self.assertEqual(before_count, after_count)
def test_follow(self):
url = FOLLOW_URL.format(self.linghu.id)
# 需要登录才能 follow 别人
response = self.anonymous_client.post(url)
self.assertEqual(response.status_code, 403)
# 要用 get 来 follow
response = self.dongxie_client.get(url)
self.assertEqual(response.status_code, 405)
# 不可以 follow 自己
response = self.linghu_client.post(url)
self.assertEqual(response.status_code, 400)
# follow 成功
response = self.dongxie_client.post(url)
# self.assertEqual(response.status_code, 201)
# self.assertEqual('created_at' in response.data, True)
# self.assertEqual('user' in response.data, True)
# self.assertEqual(response.data['user']['id'], self.linghu.id)
# self.assertEqual(response.data['user']['username'], self.linghu.username)
# 重复 follow 会 400
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 400)
# 反向关注会创建新的数据
before_count = FriendshipService.get_following_count(self.linghu.id)
response = self.linghu_client.post(FOLLOW_URL.format(self.dongxie.id))
self.assertEqual(response.status_code, 201)
after_count = FriendshipService.get_following_count(self.linghu.id)
self.assertEqual(after_count, before_count + 1)
def test_unfollow(self):
url = UNFOLLOW_URL.format(self.linghu.id)
# 需要登录才能 unfollow 别人
response = self.anonymous_client.post(url)
self.assertEqual(response.status_code, 403)
# 不能用 get 来 unfollow 别人
response = self.dongxie_client.get(url)
self.assertEqual(response.status_code, 405)
# 不能用 unfollow 自己
response = self.linghu_client.post(url)
self.assertEqual(response.status_code, 400)
# unfollow 成功
self.create_friendship(self.dongxie, self.linghu)
before_count = FriendshipService.get_following_count(self.dongxie.id)
response = self.dongxie_client.post(url)
after_count = FriendshipService.get_following_count(self.dongxie.id)
self.assertEqual(response.status_code, 204)
self.assertEqual(response.data['deleted'], 1)
self.assertEqual(after_count, before_count - 1)
# 未 follow 的情况下 unfollow 静默处理
before_count = FriendshipService.get_following_count(self.dongxie.id)
response = self.dongxie_client.post(url)
after_count = FriendshipService.get_following_count(self.dongxie.id)
self.assertEqual(response.status_code, 204)
self.assertEqual(response.data['deleted'], 0)
self.assertEqual(after_count, before_count)
def test_follow(self):
url = FOLLOW_URL.format(self.ray.id)
# login to follow others
response = self.anonymous_client.post(url)
self.assertEqual(response.status_code, 403)
# use GET to follow
response = self.lux_client.get(url)
self.assertEqual(response.status_code, 405)
# can't follow yourself
response = self.ray_client.post(url)
self.assertEqual(response.status_code, 400)
# follow successfully
response = self.lux_client.post(url)
self.assertEqual(response.status_code, 201)
# repeating follow is muted instead of throwing exceptions
response = self.lux_client.post(url)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['duplicate'], True)
# reverse follow will create new data
before_count = FriendshipService.get_following_count(self.ray.id)
response = self.ray_client.post(FOLLOW_URL.format(self.lux.id))
self.assertEqual(response.status_code, 201)
after_count = FriendshipService.get_following_count(self.ray.id)
self.assertEqual(after_count, before_count + 1)
def test_unfollow(self):
url = UNFOLLOW_URL.format(self.ray.id)
# log in to unfollow others
response = self.anonymous_client.post(url)
self.assertEqual(response.status_code, 403)
# can't use get to unfollow others
response = self.lux_client.get(url)
self.assertEqual(response.status_code, 405)
# can't unfollow yourself
response = self.ray_client.post(url)
self.assertEqual(response.status_code, 400)
# unfollow successfully
self.create_friendship(from_user=self.lux, to_user=self.ray)
before_count = FriendshipService.get_following_count(self.lux.id)
response = self.lux_client.post(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['deleted'], 1)
after_count = FriendshipService.get_following_count(self.lux.id)
self.assertEqual(after_count, before_count - 1)
# If not following, unfollow request will be muted
before_count = FriendshipService.get_following_count(self.lux.id)
response = self.lux_client.post(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['deleted'], 0)
after_count = FriendshipService.get_following_count(self.lux.id)
self.assertEqual(before_count, after_count)
def test_follow(self):
url = FOLLOW_URL.format(self.linghu.id)
# 需要登录才能 follow 别人
response = self.anonymous_client.post(url)
self.assertEqual(response.status_code, 403)
# 要用 get 来 follow
response = self.dongxie_client.get(url)
self.assertEqual(response.status_code, 405)
# 不可以 follow 自己
response = self.linghu_client.post(url)
self.assertEqual(response.status_code, 400)
# follow 成功
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 201)
# 重复 follow 静默成功
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data['success'], False)
# 反向关注会创建新的数据
before_count = FriendshipService.get_following_count(self.linghu.id)
response = self.linghu_client.post(FOLLOW_URL.format(self.dongxie.id))
self.assertEqual(response.status_code, 201)
after_count = FriendshipService.get_following_count(self.linghu.id)
self.assertEqual(after_count, before_count + 1)
def test_follow(self):
url = FOLLOW_URL.format(self.linghu.id)
# cannot follow without login
response = self.anonymous_client.post(url)
self.assertEqual(response.status_code, 403)
# fail to follow through get
response = self.dongxie_client.get(url)
self.assertEqual(response.status_code, 405)
# cannot self-follow
response = self.linghu_client.post(url)
self.assertEqual(response.status_code, 400)
# success
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 201)
# duplicate follow
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['duplicate'], True)
# mutual follow
count = FriendshipService.get_following_count(self.linghu.id)
response = self.linghu_client.post(FOLLOW_URL.format(self.dongxie.id))
self.assertEqual(response.status_code, 201)
self.assertEqual(FriendshipService.get_following_count(self.linghu.id),
count + 1)
def test_unfollow(self):
url = UNFOLLOW_URL.format(self.linghu.id)
# need login first, then unfollow others
response = self.anonymous_client.post(url)
self.assertEqual(response.status_code, 403)
# cannot use get to unfollow
response = self.dongxie_client.get(url)
self.assertEqual(response.status_code, 405)
# cannot unfollow yourself
response = self.linghu_client.post(url)
self.assertEqual(response.status_code, 400)
# unfollow success
self.create_friendship(from_user=self.dongxie, to_user=self.linghu)
before_count = FriendshipService.get_following_count(self.dongxie.id)
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['deleted'], 1)
after_count = FriendshipService.get_following_count(self.dongxie.id)
self.assertEqual(after_count, before_count - 1)
# unfollow, then unfollow,
before_count = FriendshipService.get_following_count(self.dongxie.id)
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['deleted'], 0)
after_count = FriendshipService.get_following_count(self.dongxie.id)
self.assertEqual(before_count, after_count)
def test_follow(self):
url = FOLLOW_URL.format(self.linghu.id)
# need login first, then follow others
response = self.anonymous_client.post(url)
self.assertEqual(response.status_code, 403)
# use get to follow
response = self.dongxie_client.get(url)
self.assertEqual(response.status_code, 405)
# cannot follow yourself
response = self.linghu_client.post(url)
self.assertEqual(response.status_code, 400)
# follow success
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 201)
#self.assertEqual('created_at' in response.data, True)
#self.assertEqual('user' in response.data, True)
#self.assertEqual(response.data['user']['id'], self.linghu.id)
#self.assertEqual(response.data['user']['username'], self.linghu.username)
# dup follow, silent success
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.data['duplicate'], True)
# follow reversely will create new relation
before_count = FriendshipService.get_following_count(self.linghu.id)
response = self.linghu_client.post(FOLLOW_URL.format(self.dongxie.id))
self.assertEqual(response.status_code, 201)
after_count = FriendshipService.get_following_count(self.linghu.id)
self.assertEqual(after_count, before_count + 1)
def test_unfollow(self):
url = UNFOLLOW_URL.format(self.linghu.id)
# case 1: follow without login
response = self.anonymous_client.post(url)
self.assertEqual(response.status_code, 403)
# case 2: use get to follow
response = self.dongxie_client.get(url)
self.assertEqual(response.status_code, 405)
# case 3: self-unfollow
response = self.linghu_client.post(url)
self.assertEqual(response.status_code, 400)
# case 4: success
self.create_friendship(self.dongxie, self.linghu)
count = FriendshipService.get_following_count(
from_user_id=self.dongxie.id)
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['deleted'], 1)
self.assertEqual(
FriendshipService.get_following_count(
from_user_id=self.dongxie.id), count - 1)
# case 5: re-unfollow
count = FriendshipService.get_following_count(
from_user_id=self.dongxie.id)
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['deleted'], 0)
self.assertEqual(
FriendshipService.get_following_count(
from_user_id=self.dongxie.id), count)
# case 6: duplicate unfollow
before_count = FriendshipService.get_following_count(self.dongxie.id)
response = self.dongxie_client.post(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['deleted'], 0)
after_count = FriendshipService.get_following_count(self.dongxie.id)
self.assertEqual(before_count, after_count)
