def create(self, request):
serializer = TweetCreateSerializer(data=request.data,
context={'request': request})
if not serializer.is_valid():
return Response(
{
'success': False,
'message': 'Please check input',
'errors': serializer.errors,
},
status=400)
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
return Response(TweetSerializer(tweet).data, status=201)
def create(self, request):
serializer = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serializer.is_valid():
return Response({
"success": False,
"message": "Please check input.",
"errors": serializer.errors,
}, status=400)
# save will call create method in TweetSerializerForCreate
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
return Response(TweetSerializer(tweet).data, status=201)
def test_redis_list_limit(self):
list_limit = settings.REDIS_LIST_LENGTH_LIMIT
page_size = 20
users = [self.create_user('user{}'.format(i)) for i in range(5)]
newsfeeds = []
for i in range(list_limit + page_size):
tweet = self.create_tweet(user=users[i % 5],
content='feed{}'.format(i))
feed = self.create_newsfeed(self.linghu, tweet)
newsfeeds.append(feed)
newsfeeds = newsfeeds[::-1]
# only cached list_limit objects
cached_newsfeeds = NewsFeedService.get_cached_newsfeeds(self.linghu.id)
self.assertEqual(len(cached_newsfeeds), list_limit)
if GateKeeper.is_switch_on('switch_newsfeed_to_hbase'):
count = len(HBaseNewsFeed.filter(prefix=(self.linghu.id, None)))
else:
count = NewsFeed.objects.filter(user=self.linghu).count()
self.assertEqual(count, list_limit + page_size)
results = self._paginate_to_get_newsfeeds(self.linghu_client)
self.assertEqual(len(results), list_limit + page_size)
for i in range(list_limit + page_size):
self.assertEqual(newsfeeds[i].created_at, results[i]['created_at'])
# a followed user create a new tweet
self.create_friendship(self.linghu, self.dongxie)
new_tweet = self.create_tweet(self.dongxie, 'a new tweet')
NewsFeedService.fanout_to_followers(new_tweet)
def _test_newsfeeds_after_new_feed_pushed():
results = self._paginate_to_get_newsfeeds(self.linghu_client)
self.assertEqual(len(results), list_limit + page_size + 1)
self.assertEqual(results[0]['tweet']['id'], new_tweet.id)
for i in range(list_limit + page_size):
self.assertEqual(newsfeeds[i].created_at,
results[i + 1]['created_at'])
_test_newsfeeds_after_new_feed_pushed()
# cache expired
self.clear_cache()
_test_newsfeeds_after_new_feed_pushed()
def create(self, request, *args, **kwargs):
serializer = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serializer.is_valid():
return Response(
{
'success': False,
'message': "please check input",
'errors': serializer.errors,
},
status=400)
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
serializer = TweetSerializer(tweet, context={'request': request})
return Response(serializer.data, status=201)
def create(self, request):
"""
重载 create 方法，因为需要默认用当前登录用户作为 tweet.user
"""
serializer = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serializer.is_valid():
return Response({
'success': False,
'message': "Please check input",
'errors': serializer.errors,
}, status=400)
# save() will call create method in TweetCreateSerializer
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
serializer = TweetSerializer(tweet, context={'request': request})
return Response(serializer.data, status=201)
def create(self, request, *args, **kwargs):
"""
重载 create 方法，因为需要默认用当前登录用户作为 tweet.user
"""
serializer = TweetCreateSerializer(
data=request.data,
context={'request': request},
)
# use default validator, like min max length
if not serializer.is_valid():
return Response(
{
'success': False,
'message': "Please check input",
'errors': serializer.errors,
},
status=400)
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
return Response(TweetSerializer(tweet).data, status=201)
def create(self, request):
serializer = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serializer.is_valid():
return Response({
"success": False,
"message": "Please check input",
"errors": serializer.errors,
}, status=400)
# otherwise we have a tweet instance here
# save() will call create method in TweetSerializerForCreate
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
# Here I use TweetSerializer to show whats in the tweet
# reminder: It is different from TweetSerializerForCreate
return Response(
TweetSerializer(tweet, context={'request': request}).data,
status=201,
)
def create(self, request, *args, **kwargs):
"""
overload create function, to default the login user as a tweet.user
"""
serializer = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serializer.is_valid():
return Response(
{
'success': False,
'message': 'Please check input',
'errors': serializer.errors,
},
status=400)
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
serializer = TweetSerializer(tweet, context={'request': request})
return Response(serializer.data, status=201)
def test_redis_list_limit(self):
list_limit = settings.REDIS_LIST_LENGTH_LIMIT
page_size = 20
users = [self.create_user('user{}'.format(i)) for i in range(5)]
newsfeeds = []
for i in range(list_limit + page_size):
tweet = self.create_tweet(user=users[i % 5],
content='feed{}'.format(i))
feed = self.create_newsfeed(self.ray, tweet)
newsfeeds.append(feed)
newsfeeds = newsfeeds[::-1]
# only cached list_limit objects
cached_newsfeeds = NewsFeedService.get_cached_newsfeeds(self.ray.id)
self.assertEqual(len(cached_newsfeeds), list_limit)
queryset = NewsFeed.objects.filter(user=self.ray)
self.assertEqual(queryset.count(), list_limit + page_size)
results = self._paginate_to_get_newsfeeds(self.ray_client)
self.assertEqual(len(results), list_limit + page_size)
for i in range(list_limit + page_size):
self.assertEqual(newsfeeds[i].id, results[i]['id'])
# a followed user create a new tweet
self.create_friendship(self.ray, self.diana)
new_tweet = self.create_tweet(self.diana, 'a new tweet')
NewsFeedService.fanout_to_followers(new_tweet)
def _test_newsfeeds_after_new_feed_pushed():
results = self._paginate_to_get_newsfeeds(self.ray_client)
self.assertEqual(len(results), list_limit + page_size + 1)
self.assertEqual(results[0]['tweet']['id'], new_tweet.id)
for i in range(list_limit + page_size):
self.assertEqual(newsfeeds[i].id, results[i + 1]['id'])
_test_newsfeeds_after_new_feed_pushed()
# cache expired
self.clear_cache()
_test_newsfeeds_after_new_feed_pushed()
def create(self, request, *args, **kwargs):
"""
overload create method, need current logged in user as tweet.user
:param request:
:param args:
:param kwargs:
:return:
"""
serializer = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serializer.is_valid():
return Response({
'success': False,
'message': 'Please check input',
'error': serializer.errors,
}, status=400)
tweet = serializer.save()
NewsFeedService.fanout_to_followers(tweet)
serializer = TweetSerializer(tweet, context={'request': request})
return Response(serializer.data, status=201)
def create(self, request):
serializer = TweetSerializerForCreate(
data=request.data,
context={'request': request},
)
if not serializer.is_valid():
return Response(
{
"success": False,
"message": "Please check input.",
"errors": serializer.errors,
},
status=400)
# save will trigger create method in TweetSerializerForCreate
tweet = serializer.save()
# fanout这个方法需要较复杂的逻辑实现，而在view这一层中尽量做一些简单的显示视图的功能
# 对于复杂的逻辑实现放到service这一层中去提供
NewsFeedService.fanout_to_followers(tweet)
return Response(
TweetSerializer(tweet, context={
'request': request
}).data,
status=201,
)
def test_newsfeed_cache_limit_pagination(self):
limit_size = settings.REDIS_LIST_LENGTH_LIMIT
page_size = 20
users = [
self.create_user(username='******'.format(i))
for i in range(5)
]
newsfeeds = []
for i in range(limit_size + page_size):
tweet = self.create_tweet(user=users[i % 5])
feed = self.create_newsfeed(user=self.user2, tweet=tweet)
newsfeeds.append(feed)
newsfeeds = newsfeeds[::-1]
# newsfeed inside and outside cache
cached_newsfeeds = NewsFeedService.load_newsfeeds_through_cache(
user_id=self.user2.id
)
self.assertEqual(len(cached_newsfeeds), limit_size)
db_newsfeeds = NewsFeed.objects.filter(user=self.user2)
self.assertEqual(len(db_newsfeeds), limit_size+page_size)
paginated_newsfeeds = self._paginate_to_get_newsfeeds(
client=self.user2_client
)
self.assertEqual(len(paginated_newsfeeds), limit_size+page_size)
self.assertEqual(
[f['id'] for f in paginated_newsfeeds],
[f.id for f in newsfeeds]
)
# new posts fanout to followers' newsfeeds
celebrity, celebrity_client = self.create_user_and_client(
username='******'
)
self.create_friendship(from_user=self.user2, to_user=celebrity)
tweet_celebrity = self.create_tweet(user=celebrity)
NewsFeedService.fanout_to_followers(tweet_celebrity)
def _test_newsfeeds_after_new_feed_pushed():
db_newsfeeds = NewsFeed.objects.filter(user=self.user2)
self.assertEqual(len(db_newsfeeds), limit_size+page_size+1)
new_paginated_newsfeed = self._paginate_to_get_newsfeeds(
client=self.user2_client
)
self.assertEqual(
new_paginated_newsfeed[0]['tweet']['id'],
tweet_celebrity.id
)
for i in range(limit_size+page_size):
self.assertEqual(
new_paginated_newsfeed[i+1]['id'],
newsfeeds[i].id
)
_test_newsfeeds_after_new_feed_pushed()
# keys expire
self.clear_cache()
_test_newsfeeds_after_new_feed_pushed()
