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) # 需要登录才能 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_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) # 需要登录才能 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.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_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_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_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): 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_get_following_user_id_set(self): FriendshipService.invalidate_following_cache( from_user_id=self.user2.id) user_id_set_2 = FriendshipService.get_following_user_id_set( self.user2.id) self.assertEqual(user_id_set_2, {self.user1.id, self.user3.id}) user_id_set_1 = FriendshipService.get_following_user_id_set( self.user1.id) self.assertEqual(user_id_set_1, {self.user2.id}) Friendship.objects.filter( from_user=self.user2, to_user=self.user3, ).delete() Friendship.objects.filter( from_user=self.user1, to_user=self.user2, ).delete() # mannually clear the cache FriendshipService.invalidate_following_cache( from_user_id=self.user2.id) user_id_set_2 = FriendshipService.get_following_user_id_set( self.user2.id) self.assertEqual(user_id_set_2, {self.user1.id}) # cache automatically cleared in delete() by listener user_id_set_1 = FriendshipService.get_following_user_id_set( self.user1.id) self.assertEqual(len(user_id_set_1), 0) # cache automatically cleared in create() by listener Friendship.objects.create(from_user=self.user1, to_user=self.user3) user_id_set_1 = FriendshipService.get_following_user_id_set( self.user1.id) self.assertEqual(user_id_set_1, {self.user3.id})
def test_get_followings(self): user1 = self.create_user('user1') user2 = self.create_user('user2') for to_user in [user1, user2, self.alex]: self.create_friendship(from_user=self.bob, to_user=to_user) user_id_set = FriendshipService.get_following_user_id_set(self.bob.id) self.assertEqual(user_id_set, {user1.id, user2.id, self.alex.id}) FriendshipService.unfollow(self.bob.id, self.alex.id) user_id_set = FriendshipService.get_following_user_id_set(self.bob.id) self.assertEqual(user_id_set, {user1.id, user2.id})
def test_get_following(self): user1 = self.create_user('user1') user2 = self.create_user('user2') for to_user in [user1, user2, self.ming]: self.create_friendship(self.rui, to_user) user_id_set = FriendshipService.get_following_user_id_set(self.rui.id) self.assertSetEqual(user_id_set, {user1.id, user2.id, self.ming.id}) FriendshipService.unfollow(self.rui.id, self.ming.id) user_id_set = FriendshipService.get_following_user_id_set(self.rui.id) self.assertSetEqual(user_id_set, {user1.id, user2.id})
def test_get_followings(self): user1 = self.create_user('user1') user2 = self.create_user('user2') for to_user in [user1, user2, self.lux]: Friendship.objects.create(from_user=self.ray, to_user=to_user) user_id_set = FriendshipService.get_following_user_id_set(self.ray.id) self.assertSetEqual(user_id_set, {user1.id, user2.id, self.lux.id}) Friendship.objects.filter(from_user=self.ray, to_user=self.lux).delete() user_id_set = FriendshipService.get_following_user_id_set(self.ray.id) self.assertSetEqual(user_id_set, {user1.id, user2.id})
def test_get_followings(self): user3 = self.create_user('user3') user4 = self.create_user('user4') for to_user in [self.user2, user3, user4]: Friendship.objects.create(to_user=to_user, from_user=self.user1) user_id_set = FriendshipService.get_following_user_id_set( self.user1.id) self.assertEqual(user_id_set, {self.user2.id, user3.id, user4.id}) Friendship.objects.filter(to_user=self.user2, from_user=self.user1).delete() user_id_set = FriendshipService.get_following_user_id_set( self.user1.id) self.assertEqual(user_id_set, {user3.id, user4.id})
def test_get_followings(self): user1 = self.create_user('user1') user2 = self.create_user('user2') for to_user in [user1, user2, self.dongxie]: Friendship.objects.create(from_user=self.linghu, to_user=to_user) user_id_set = FriendshipService.get_followed_user_id_set( self.linghu.id) self.assertEqual(user_id_set, {user1.id, user2.id, self.dongxie.id}) Friendship.objects.filter(from_user=self.linghu, to_user=self.dongxie).delete() user_id_set = FriendshipService.get_followed_user_id_set( self.linghu.id) self.assertEqual(user_id_set, {user1.id, user2.id})
def follow(self, request, pk): # /api/friendships/<pk>/follow/ # 特殊判断重复 follow 的情况(比如前端猛点好多少次 follow) # 静默处理,不报错,因为这类重复操作因为网络延迟的原因会比较多,没必要当做错误处理 # get_object 会检测if user with id=pk 是否存在,如果不存在会return 404 异常 follow_user = self.get_object() if FriendshipService.has_followed(request.user.id, int(pk)): return Response({ 'success': True, 'duplicate': True, }, status=status.HTTP_201_CREATED) serializer = FriendshipSerializerForCreate( data={ 'from_user_id': request.user.id, 'to_user_id': pk, }) if not serializer.is_valid(): return Response({ 'success': False, 'errors': serializer.errors, }, status=status.HTTP_400_BAD_REQUEST) instance = serializer.save() return Response( # instead returning success=> true, returning the pk (the request tries to follow the pk) data # the return data includes user_id, created_at FollowingSerializer(instance, context={ 'request': request }).data, status=status.HTTP_201_CREATED, )
def create(self, validated_data): from_user_id = validated_data['from_user_id'] to_user_id = validated_data['to_user_id'] return FriendshipService.follow( from_user_id=from_user_id, to_user_id=to_user_id, )
def follow(self, request, pk): if FriendshipService.has_followed(request.user.id, int(pk)): return Response({ 'success': True, 'duplicate': True, }, status=status.HTTP_201_CREATED) serializer = FriendshipSerializerForCreate( data={ 'from_user_id': request.user.id, 'to_user_id': pk, }) if not serializer.is_valid(): return Response({ 'success': False, 'errors': serializer.errors, }, status=status.HTTP_400_BAD_REQUEST) instance = serializer.save() return Response( FollowingSerializer(instance, context={ 'request': request }).data, status=status.HTTP_201_CREATED, )
def unfollow(self, request, pk): to_user = self.get_object() # not support unfollow yourself if request.user.id == to_user.id: return Response( { 'success': False, 'message': "You cannot unfollow yourself." }, status=status.HTTP_400_BAD_REQUEST) # delete the friendship delete = FriendshipService.unfollow( from_user_id=request.user.id, # only logged in user can unfollow to_user_id=to_user.id, ) # delete as the number of objects deleted if not delete: return Response('Friendship not exists', status=status.HTTP_400_BAD_REQUEST) return Response({ 'success': True, 'deleted': '{}'.format(delete), }, status=status.HTTP_200_OK)
def fanout_to_followers(cls, tweet): newsfeeds = [ NewsFeed(user=follower, tweet=tweet) for follower in FriendshipService.get_followers(tweet.user) ] newsfeeds.append(NewsFeed(user=tweet.user, tweet=tweet)) NewsFeed.objects.bulk_create(newsfeeds)
def follow(self, request, pk): # 特殊判断重复 follow 的情况(比如前端猛点好多少次 follow) # 静默处理,不报错,因为这类重复操作因为网络延迟的原因会比较多,没必要当做错误处理 to_follow_user = self.get_object() if FriendshipService.has_followed(request.user.id, to_follow_user.id): return Response( { 'success': False, 'message': 'Please check input', 'errors': [{ 'pk': f'You has followed user with id={pk}' }], }, status=status.HTTP_400_BAD_REQUEST) serializer = FriendshipSerializerForCreate( data={ 'from_user_id': request.user.id, 'to_user_id': pk, }) if not serializer.is_valid(): return Response( { "success": False, "message": "Please check input.", "errors": serializer.errors, }, status=status.HTTP_400_BAD_REQUEST) instance = serializer.save() return Response( FollowingSerializer(instance, context={ 'request': request }).data, status=status.HTTP_201_CREATED, )
def follow(self, request, pk): # check i fuser with id=pk exists # self.get_object() # 特殊判断重复 follow 的情况 (比如前端猛点多次follow) # 静默处理, 不报错, 因为这类重复操作 因为网络延迟的原因会比较多, 没必要当做错误处理 if FriendshipService.has_followed(request.user.id, int(pk)): return Response({ 'success': True, 'duplicate': True, }, status=status.HTTP_201_CREATED) serializer = FriendshipSerializerForCreate( data={ 'from_user_id': request.user.id, 'to_user_id': pk, }) if not serializer.is_valid(): return Response({ 'success': False, 'errors': serializer.errors, }, status=status.HTTP_400_BAD_REQUEST) serializer.save() return Response({'success': True}, status=status.HTTP_201_CREATED)
def follow(self, request, pk): # egde case check: duplicate follow action (e.g. multiple clicks from frontend) # silent processing. No need to report error. # because this kind of duplicated operation are mostly because of internet delay, if FriendshipService.has_followed(request.user.id, int(pk)): return Response( { 'success': True, 'duplicate': True, 'error': [{ 'pk': f'you have followed the user with id={pk}' }], }, status=status.HTTP_400_BAD_REQUEST) serializer = FriendshipSerializerForCreate( data={ 'from_user_id': request.user.id, 'to_user_id': pk, }) if not serializer.is_valid(): return Response({ 'success': False, 'errors': serializer.errors, }, status=status.HTTP_400_BAD_REQUEST) instance = serializer.save() return Response( FollowingSerializer(instance, context={ 'request': request }).data, status=status.HTTP_201_CREATED, )
def follow(self, request, pk): # check if the user to follow exists to_user = self.get_object() # Friendship already existed. Raise error # avoid duplicated friendships in HBase if FriendshipService.has_followed(from_user_id=request.user.id, to_user_id=to_user.id): return Response({ 'success': True, 'duplicated': True, }, status=status.HTTP_201_CREATED) # Friendship not exists, creat new friendship serializer = FriendshipCreateSerializer( data={ 'from_user_id': request.user.id, # only logged in user can follow 'to_user_id': pk, }) if not serializer.is_valid(): return Response({ 'success': False, 'errors': serializer.errors, }, status=status.HTTP_400_BAD_REQUEST) friendship = serializer.save() return Response( { 'success': True, 'friendship': FriendshipCreateSerializer(friendship).data, }, status=status.HTTP_201_CREATED)
def follow(self, request, pk): # check if user with id=pk exists to_follow_user = self.get_object() if FriendshipService.has_followed(request.user.id, to_follow_user.id): return Response({ 'success': False, 'message': 'Please check input', 'errors': [{'pk': f'You has followed user with id={pk}'}], }, status=status.HTTP_400_BAD_REQUEST) # /api/friendships/<pk>/follow/ serializer = FriendshipSerializerForCreate(data={ 'from_user_id': request.user.id, 'to_user_id': to_follow_user.id, }) if not serializer.is_valid(): return Response({ 'success': False, 'message': 'Please check input', 'errors': serializer.errors, }, status=status.HTTP_400_BAD_REQUEST) instance = serializer.save() return Response( FollowingSerializer(instance, context={'request': request}).data, status=status.HTTP_201_CREATED )
def test_get_followings(self): user3 = self.create_user('user3') user4 = self.create_user('user4') for to_user in [user3, user4, self.user2]: Friendship.objects.create(from_user=self.user1, to_user=to_user) # FriendshipService.invalidate_following_cache(from_user_id=self.user1.id) user_id_set = FriendshipService.get_following_user_id_set( self.user1.id) self.assertEqual(user_id_set, {user3.id, user4.id, self.user2.id}) Friendship.objects.filter(from_user=self.user1.id, to_user=self.user2.id).delete() # FriendshipService.invalidate_following_cache(from_user_id=self.user1.id) user_id_set = FriendshipService.get_following_user_id_set( self.user1.id) self.assertEqual(user_id_set, {user3.id, user4.id})
def fanout_to_followers(cls, tweet): # 错误的方法 # 不可以将数据库操作放在 for 循环里面,效率会非常低 # for follower in FriendshipService.get_followers(tweet.user): # NewsFeed.objects.create( # user=follower, # tweet=tweet, # ) # 正确的方法:使用 bulk_create,会把 insert 语句合成一条 print(FriendshipService.get_followers(tweet.user)) newsfeeds = [ NewsFeed(user=follower, tweet=tweet) for follower in FriendshipService.get_followers(tweet.user) ] newsfeeds.append(NewsFeed(user=tweet.user, tweet=tweet)) NewsFeed.objects.bulk_create(newsfeeds)