def setUp(self) -> None:
self.clear_cache()
RedisClient.clear()
self.user1, self.user1_client = self.create_user_and_client(
username='******')
self.user2, self.user2_client = self.create_user_and_client(
username='******')
def test_get_user_newsfeeds(self):
newsfeed_ids = []
for i in range(3):
tweet = self.create_tweet(self.dongxie)
newsfeed = self.create_newsfeed(self.linghu, tweet)
newsfeed_ids.append(newsfeed.id)
newsfeed_ids = newsfeed_ids[::-1]
RedisClient.clear()
conn = RedisClient.get_connection()
# cache miss
newsfeeds = NewsFeedService.get_cached_newsfeeds(self.linghu.id)
self.assertEqual([f.id for f in newsfeeds], newsfeed_ids)
# cache hit
newsfeeds = NewsFeedService.get_cached_newsfeeds(self.linghu.id)
self.assertEqual([f.id for f in newsfeeds], newsfeed_ids)
# cache updated
tweet = self.create_tweet(self.linghu)
new_newsfeed = self.create_newsfeed(self.linghu, tweet)
newsfeeds = NewsFeedService.get_cached_newsfeeds(self.linghu.id)
newsfeed_ids.insert(0, new_newsfeed.id)
self.assertEqual([f.id for f in newsfeeds], newsfeed_ids)
def setUp(self):
self.clear_cache()
RedisClient.clear()
self.user_1 = User.objects.create_user(username='******',
password='******')
self.user_2 = User.objects.create_user(username='******',
password='******')
def clear_cache(self):
caches['testing'].clear()
RedisClient.clear()
# 可以手动切换是否使用 Hbase
GateKeeper.turn_on('switch_newsfeed_to_hbase')
GateKeeper.turn_on('switch_friendship_to_hbase')
def setUp(self) -> None:
self.clear_cache()
RedisClient.clear()
self.user1, self.user1_client = self.create_user_and_client(
username='******')
# dummy tweets
self.tweets = []
self.tweets = [self.create_tweet(user=self.user1) for i in range(41)]
self.tweets = self.tweets[::-1] # order by created_at in descending
def test_redis_client(self):
conn = RedisClient.get_connection()
conn.lpush('redis_key', 1)
conn.lpush('redis_key', 2)
cached_list = conn.lrange('redis_key', 0, -1)
self.assertEqual(cached_list, [b'2', b'1'])
RedisClient.clear()
cached_list = conn.lrange('redis_key', 0, -1)
self.assertEqual(cached_list, [])
def test_create_new_tweet_before_get_cached_tweets(self):
tweet1 = self.create_tweet(self.user1, 'test tweet')
RedisClient.clear()
conn = RedisClient.get_connection()
key = USER_TWEET_PATTERN.format(user_id=self.user1.id)
self.assertEqual(conn.exists(key), False)
tweet2 = self.create_tweet(self.user1, 'another tweet')
self.assertEqual(conn.exists(key), True)
tweets = TweetService.get_cached_tweets(self.user1)
self.assertEqual([tweet.id for tweet in tweets], [tweet2.id, tweet1.id])
def test_redis_client(self):
conn = RedisClient.get_connection()
conn.lpush('redis_key', 1)
conn.lpush('redis_key', 2)
# from index 0 to the last element (-1)
cached_list = conn.lrange('redis_key', 0, -1)
# elements without deserialization are saved as strings so we need a prefix b (byte)
self.assertEqual(cached_list, [b'2', b'1'])
RedisClient.clear()
cached_list = conn.lrange('redis_key', 0, -1)
self.assertEqual(cached_list, [])
def test_create_tweet_before_get_cached_tweets(self):
tweet1 = self.create_tweet(user=self.user1)
RedisClient.clear()
conn = RedisClient.get_connection()
name = USER_TWEET_PATTERN.format(user_id=self.user1.id)
self.assertFalse(conn.exists(name))
tweet2 = self.create_tweet(user=self.user1)
self.assertTrue(conn.exists(name))
tweets = TweetService.load_tweets_through_cache(user_id=self.user1.id)
self.assertEqual([t.id for t in tweets], [tweet2.id, tweet1.id])
def test_create_new_newsfeed_before_get_cached_newsfeeds(self):
feed1 = self.create_newsfeed(self.ray, self.create_tweet(self.ray))
RedisClient.clear()
conn = RedisClient.get_connection()
key = USER_NEWSFEEDS_PATTERN.format(user_id=self.ray.id)
self.assertEqual(conn.exists(key), False)
feed2 = self.create_newsfeed(self.ray, self.create_tweet(self.ray))
self.assertEqual(conn.exists(key), True)
feeds = NewsFeedService.get_cached_newsfeeds(self.ray.id)
self.assertEqual([f.id for f in feeds], [feed2.id, feed1.id])
def setUp(self):
self.clear_cache()
RedisClient.clear()
self.user1_client = APIClient()
self.user1 = self.create_user(username='******')
self.user1_client.force_authenticate(user=self.user1)
self.user1_tweets = [
self.create_tweet(self.user1, i)
for i in range(3) # 3 tweets for user_1
]
self.user2_client = APIClient()
self.user2 = self.create_user(username='******')
self.user2_client.force_authenticate(user=self.user2)
self.user2_tweets = [
self.create_tweet(self.user2, i)
for i in range(2) # 2 tweets for user_2
]
self.user3, self.user3_client = self.create_user_and_client(
username='******')
def test_get_user_tweets(self):
tweet_ids = []
for i in range(3):
tweet = self.create_tweet(self.linghu, 'tweet {}'.format(i))
tweet_ids.append(tweet.id)
tweet_ids = tweet_ids[::-1]
RedisClient.clear()
conn = RedisClient.get_connection()
# cache miss
tweets = TweetService.get_cached_tweets(self.linghu.id)
self.assertEqual([t.id for t in tweets], tweet_ids)
# cache hit
tweets = TweetService.get_cached_tweets(self.linghu.id)
self.assertEqual([t.id for t in tweets], tweet_ids)
# cache updated
new_tweet = self.create_tweet(self.linghu, 'new tweet')
tweets = TweetService.get_cached_tweets(self.linghu.id)
tweet_ids.insert(0, new_tweet.id)
self.assertEqual([t.id for t in tweets], tweet_ids)
def setUp(self):
RedisClient.clear()
def setUp(self):
self.clear_cache()
RedisClient.clear()
self.user1 = self.create_user('user1')
def clear_cache(self):
caches['testing'].clear()
RedisClient.clear()
GateKeeper.turn_on('switch_newsfeed_to_hbase')
def clear_cache(self):
caches['testing'].clear()
RedisClient.clear()
def clear_cache(self):
RedisClient.clear()
caches['testing'].clear()
GateKeeper.set_kv('switch_friendship_to_hbase', 'percent', 100)
