def test_default_manager_recent(self):
"The default manager includes tweets from public AND private users"
public_user = UserFactory(is_private=False)
private_user = UserFactory(is_private=True)
public_tweets = TweetFactory.create_batch(2, user=public_user)
private_tweet = TweetFactory(user=private_user)
self.assertEqual(len(Tweet.objects.all()), 3)
def setUp(self):
self.user_1 = UserFactory(screen_name='terry')
self.user_2 = UserFactory(screen_name='bob')
self.user_3 = UserFactory(screen_name='thelma', is_private=True)
self.account_1 = AccountFactory(user=self.user_1)
account_2 = AccountFactory(user=self.user_2)
account_3 = AccountFactory(user=self.user_3) # private
# Public tweets in 2015 and 2016:
tweets2015 = TweetFactory.create_batch(
3, post_time=datetime_from_str('2015-01-01 12:00:00'))
tweets2016 = TweetFactory.create_batch(
2, post_time=datetime_from_str('2016-01-01 12:00:00'))
# One private tweet in 2015:
private_tweet = TweetFactory(
post_time=datetime_from_str('2015-01-01 12:00:00'))
private_tweet.user.is_private = True
private_tweet.user.save()
self.account_1.user.favorites.add(private_tweet)
self.account_1.user.favorites.add(tweets2015[0])
self.account_1.user.favorites.add(tweets2015[1])
self.account_1.user.favorites.add(tweets2015[2])
self.account_1.user.favorites.add(tweets2016[0])
self.account_1.user.favorites.add(tweets2016[1])
account_2.user.favorites.add(tweets2015[1])
account_2.user.favorites.add(tweets2016[1])
account_3.user.favorites.add(tweets2015[1]) # private user favoriting
def setUp(self):
user_1 = UserFactory(screen_name='terry')
user_2 = UserFactory(screen_name='bob')
user_3 = UserFactory(screen_name='thelma', is_private=True)
account_1 = AccountFactory(user=user_1)
account_2 = AccountFactory(user=user_2)
account_3 = AccountFactory(user=user_3)
self.tweets = TweetFactory.create_batch(6)
# One of the tweets is private:
self.tweets[0].user.is_private = True
self.tweets[0].user.save()
post_time = datetime.datetime(2015, 3, 18, 12, 0,
0).replace(tzinfo=pytz.utc)
self.tweets[0].post_time = post_time
self.tweets[0].save()
self.tweets[1].post_time = post_time + datetime.timedelta(hours=1)
self.tweets[1].save()
self.tweets[5].post_time = post_time + datetime.timedelta(hours=2)
self.tweets[5].save()
account_1.user.favorites.add(self.tweets[0]) # private tweet
account_1.user.favorites.add(self.tweets[1])
account_1.user.favorites.add(self.tweets[2])
account_1.user.favorites.add(self.tweets[3])
account_2.user.favorites.add(self.tweets[4])
account_3.user.favorites.add(self.tweets[5]) # private user favoriting
def test_ordering(self):
"""Multiple accounts are by user.screen_name time ascending"""
user_1 = UserFactory(screen_name='terry')
user_2 = UserFactory(screen_name='june')
account_1 = AccountFactory(user=user_1)
account_2 = AccountFactory(user=user_2)
accounts = Account.objects.all()
self.assertEqual(accounts[0].pk, account_2.pk)
def test_makes_description_html(self, htmlify_method):
"When save() is called description_html should be created from raw JSON"
htmlify_method.return_value = 'my test description'
user = UserFactory()
user.raw = '{"description":"my test description"}'
user.save()
htmlify_method.assert_called_once_with(
{'description': 'my test description'})
self.assertEqual(user.description_html, 'my test description')
def test_default_manager(self):
"Default Manager shows both private and public photos"
public_user = UserFactory(is_private=False)
private_user = UserFactory(is_private=True)
public_tweet = TweetFactory(user=public_user)
private_tweet = TweetFactory(user=private_user)
public_photos = PhotoFactory.create_batch(2, tweets=(public_tweet,))
private_photos = PhotoFactory.create_batch(1, tweets=(private_tweet,))
self.assertEqual(len(Media.objects.all()), 3)
def test_makes_description_html(self, htmlify_method):
"When save() is called description_html should be created from raw JSON"
htmlify_method.return_value = 'my test description'
user = UserFactory()
user.raw = '{"description":"my test description"}'
user.save()
htmlify_method.assert_called_once_with(
{'description': 'my test description'})
self.assertEqual(user.description_html, 'my test description')
def test_public_manager(self):
"The public manager ONLY includes tweets from public users"
public_user = UserFactory(is_private=False)
private_user = UserFactory(is_private=True)
public_tweets = TweetFactory.create_batch(2, user=public_user)
private_tweet = TweetFactory(user=private_user)
tweets = Tweet.public_objects.all()
self.assertEqual(len(tweets), 2)
self.assertEqual(tweets[0].pk, public_tweets[1].pk)
self.assertEqual(tweets[1].pk, public_tweets[0].pk)
def setUp(self):
user_1 = UserFactory(screen_name='terry')
user_2 = UserFactory(screen_name='bob', is_private=True)
user_3 = UserFactory(screen_name='thelma')
account_1 = AccountFactory(user=user_1)
account_2 = AccountFactory(user=user_2)
account_3 = AccountFactory(user=user_3)
self.tweets_1 = TweetFactory.create_batch(2, user=user_1)
self.tweets_2 = TweetFactory.create_batch(3, user=user_2)
self.tweets_3 = TweetFactory.create_batch(4, user=user_3)
def test_going_public(self):
"Makes the user's tweets public if they go public"
# Start off private:
user = UserFactory(is_private=True)
tweet = TweetFactory(user=user)
self.assertTrue(tweet.is_private)
# Now change to public:
user.is_private = False
# Should change the user's tweets to public:
user.save()
tweet.refresh_from_db()
self.assertFalse(tweet.is_private)
def setUp(self):
"""We add the last_recent_id and last_favorite_id to prevent the
fetcher fetching multiple pages of tweets. Keeps things simpler.
"""
user_1 = UserFactory(screen_name='jill', twitter_id=1)
user_2 = UserFactory(screen_name='debs', twitter_id=2)
self.account_1 = AccountWithCredentialsFactory(user=user_1,
last_recent_id=100,
last_favorite_id=100)
self.account_2 = AccountWithCredentialsFactory(user=user_2,
last_recent_id=100,
last_favorite_id=100)
def test_going_public(self):
"Makes the user's tweets public if they go public"
# Start off private:
user = UserFactory(is_private=True)
tweet = TweetFactory(user=user)
self.assertTrue(tweet.is_private)
# Now change to public:
user.is_private = False
# Should change the user's tweets to public:
user.save()
tweet.refresh_from_db()
self.assertFalse(tweet.is_private)
def test_public_favorites_tweets_manager(self):
"Should contain recent PUBLIC tweets favorited the Accounts"
accounts = AccountFactory.create_batch(2)
public_user = UserFactory(is_private=False)
private_user = UserFactory(is_private=True)
public_tweet = TweetFactory(user=public_user)
private_tweet = TweetFactory(user=private_user)
accounts[0].user.favorites.add(private_tweet)
accounts[0].user.favorites.add(public_tweet)
accounts[1].user.favorites.add(private_tweet)
favorites = Tweet.public_favorite_objects.all()
self.assertEqual(len(favorites), 1)
self.assertEqual(favorites[0].pk, public_tweet.pk)
def test_updates_users(self):
user = UserFactory.create(
twitter_id=26727655, screen_name='bill')
self.add_response(body=self.make_response_body())
result = UsersFetcher(screen_name='jill').fetch([460060168, 26727655, 6795192])
self.assertEqual('Aiannucci',
User.objects.get(twitter_id=26727655).screen_name)
def test_public_favorites_accounts_manager(self):
"Should only show tweets favorited by public Accounts"
public_user = UserFactory(is_private=False)
private_user = UserFactory(is_private=True)
account_1 = AccountFactory(user=public_user)
account_2 = AccountFactory(user=private_user)
tweets = TweetFactory.create_batch(5)
account_1.user.favorites.add(tweets[0])
account_1.user.favorites.add(tweets[3])
account_2.user.favorites.add(tweets[1])
account_2.user.favorites.add(tweets[3])
favorites = Tweet.public_favorite_objects.all()
self.assertEqual(len(favorites), 2)
self.assertEqual(favorites[0].pk, tweets[3].pk)
self.assertEqual(favorites[1].pk, tweets[0].pk)
def test_updates_users(self):
user = UserFactory.create(twitter_id=26727655, screen_name='bill')
self.add_response(body=self.make_response_body())
result = UsersFetcher(screen_name='jill').fetch(
[460060168, 26727655, 6795192])
self.assertEqual('Aiannucci',
User.objects.get(twitter_id=26727655).screen_name)
def test_requests_all_users(self):
"If no ids supplied, uses all users in the DB"
users = UserFactory.create_batch(5)
result = UsersFetcher(screen_name='jill').fetch()
ids = User.objects.values_list('twitter_id', flat=True).order_by('fetch_time')
ids = '%2C'.join(map(str, ids))
self.assertIn(ids, responses.calls[0][0].url)
def test_ignores_account_with_no_creds(self, download):
# Quietly prevents avatar files being fetched:
download.side_effect = DownloadException('Oops')
user_3 = UserFactory()
account_3 = AccountFactory(user=user_3)
self.add_response(body=self.make_response_body())
result = RecentTweetsFetcher().fetch()
self.assertEqual(2, len(responses.calls))
def test_with_accounts_manager(self):
"Only returns Users with Accounts"
users = UserFactory.create_batch(4)
account_1 = AccountFactory(user=users[0])
account_2 = AccountFactory(user=users[2])
users_with_accounts = User.objects_with_accounts.all()
self.assertEqual(2, len(users_with_accounts))
self.assertEqual(users_with_accounts[0].pk, users[0].pk)
self.assertEqual(users_with_accounts[1].pk, users[2].pk)
def test_with_accounts_manager(self):
"Only returns Users with Accounts"
users = UserFactory.create_batch(4)
account_1 = AccountFactory(user=users[0])
account_2 = AccountFactory(user=users[2])
users_with_accounts = User.objects_with_accounts.all()
self.assertEqual(2, len(users_with_accounts))
self.assertEqual(users_with_accounts[0].pk, users[0].pk)
self.assertEqual(users_with_accounts[1].pk, users[2].pk)
def test_returns_error_if_no_creds(self):
"If an account has no API credentials, the result is correct"
user = UserFactory(screen_name='bobby')
account = AccountFactory(user=user)
self.add_response(body=self.make_response_body())
result = VerifyFetcher(screen_name='bobby').fetch()
self.assertFalse(result[0]['success'])
self.assertIn('Account has no API credentials',
result[0]['messages'][0])
def test_requests_all_users(self):
"If no ids supplied, uses all users in the DB"
users = UserFactory.create_batch(5)
result = UsersFetcher(screen_name='jill').fetch()
ids = User.objects.values_list('twitter_id',
flat=True).order_by('fetch_time')
ids = '%2C'.join(map(str, ids))
self.assertIn(ids, responses.calls[0][0].url)
def test_ignores_account_with_no_creds(self, download):
# This will just stop us requesting avatars from Twitter:
download.side_effect = DownloadException('Ooops')
# Add a third Account that has no API credentials:
account_3 = AccountFactory(user=UserFactory())
self.add_response(body=self.make_response_body())
result = FavoriteTweetsFetcher().fetch()
# Should only have fetched faves for the two accounts with API creds:
self.assertEqual(2, len(responses.calls))
def setUp(self):
user_1 = UserFactory(screen_name='terry')
user_2 = UserFactory(screen_name='bob')
user_3 = UserFactory(screen_name='thelma', is_private=True)
account_1 = AccountFactory(user=user_1)
account_2 = AccountFactory(user=user_2)
account_3 = AccountFactory(user=user_3)
tweets = TweetFactory.create_batch(6)
# One of the tweets is private:
tweets[0].user.is_private = True
tweets[0].user.save()
account_1.user.favorites.add(tweets[0])
account_1.user.favorites.add(tweets[1])
account_1.user.favorites.add(tweets[3])
account_2.user.favorites.add(tweets[5])
# Private user favoriting public tweets:
account_3.user.favorites.add(tweets[5])
def setUp(self):
user_1 = UserFactory(screen_name='terry')
user_2 = UserFactory(screen_name='bob')
user_3 = UserFactory(screen_name='thelma', is_private=True)
account_1 = AccountFactory(user=user_1)
account_2 = AccountFactory(user=user_2)
account_3 = AccountFactory(user=user_3)
self.tweets_1 = TweetFactory.create_batch(2, user=user_1)
self.tweets_2 = TweetFactory.create_batch(2, user=user_2)
self.tweets_3 = TweetFactory.create_batch(2, user=user_3)
post_time = datetime.datetime(2015, 3, 18, 12, 0,
0).replace(tzinfo=pytz.utc)
self.tweets_1[0].post_time = post_time
self.tweets_1[0].save()
self.tweets_2[1].post_time = post_time + datetime.timedelta(hours=1)
self.tweets_2[1].save()
self.tweets_3[0].post_time = post_time + datetime.timedelta(hours=2)
self.tweets_3[0].save()
def test_does_not_update_user(self):
"Shouldn't fetch user from API on save if it already has a user"
self.add_response(body=self.make_verify_credentials_body(),
call='account/verify_credentials')
user = UserFactory(twitter_id=12552, screen_name='oldname')
account = AccountWithCredentialsFactory(user=user)
self.assertIsInstance(account.user, User)
# Screen name is not changed to the one in our mocked API response:
self.assertEqual(account.user.screen_name, 'oldname')
self.assertEqual(0, len(responses.calls))
def test_favorites(self):
user = UserFactory(screen_name='bill')
tweet_1 = TweetFactory(text ='Tweet 1')
tweet_2 = TweetFactory(text ='Tweet 2')
user.favorites.add(tweet_1)
user.favorites.add(tweet_2)
faves = User.objects.get(screen_name='bill').favorites.all()
self.assertEqual(len(faves), 2)
self.assertIsInstance(faves[0], Tweet)
self.assertEqual(faves[0].text, 'Tweet 2')
self.assertEqual(faves[1].text, 'Tweet 1')
def test_saves_users(self):
"Updates the Account's user data in the DB with fetched data."
user = UserFactory(twitter_id=12552,
screen_name='philgyford',
name='This should change')
account = AccountWithCredentialsFactory(id=4, user=user)
self.add_response(body=self.make_response_body())
result = VerifyFetcher(screen_name='philgyford').fetch()
user_reloaded = User.objects.get(screen_name='philgyford')
self.assertEqual(user_reloaded.name, 'Phil Gyford')
def setUp(self):
dt = datetime.datetime.strptime(
'2016-04-08 12:00:00', '%Y-%m-%d %H:%M:%S'
).replace(tzinfo=pytz.utc)
user = UserFactory()
account = AccountFactory(user=user)
self.tweet_1 = TweetFactory(user=user, post_time=dt)
private_user = UserFactory(is_private=True)
private_account = AccountFactory(user=private_user)
self.private_tweeet = TweetFactory(user=private_user,
post_time=dt + datetime.timedelta(days=1))
# Tweet by a different user:
user_2 = UserFactory()
account_2 = AccountFactory(user=user_2)
self.other_tweet = TweetFactory(user=user_2,
post_time=dt + datetime.timedelta(days=2))
self.tweet_2 = TweetFactory(user=user,
post_time=dt + datetime.timedelta(days=3))
def setUp(self):
self.user_1 = UserFactory(screen_name='terry')
self.user_2 = UserFactory(screen_name='bob')
self.user_3 = UserFactory(screen_name='thelma', is_private=True)
account_1 = AccountFactory(user=self.user_1)
account_2 = AccountFactory(user=self.user_2)
account_3 = AccountFactory(user=self.user_3)
# Tweets in 2015 and 2016 for user 1:
TweetFactory.create_batch(
3,
post_time=datetime_from_str('2015-01-01 12:00:00'),
user=self.user_1)
TweetFactory.create_batch(
2,
post_time=datetime_from_str('2016-01-01 12:00:00'),
user=self.user_1)
# And one for self.user_2 in 2015:
TweetFactory(user=self.user_2,
post_time=datetime_from_str('2015-01-01 12:00:00'))
# And one tweet in 2015 for the private user 3.
tw = TweetFactory(user=self.user_3,
is_private=True,
post_time=datetime_from_str('2015-01-01 12:00:00'))
def test_fetch_for_account_updates(self, fetch_avatar):
"Saves and returns updated existing user after successful API call"
# Just make the mocked method return the User that's passed in:
fetch_avatar.side_effect = lambda value: value
self.add_response(body=self.make_response_body())
user = UserFactory(twitter_id=12552, screen_name='bob')
account = AccountWithCredentialsFactory(user=user)
result = FetchVerify(account=account).fetch()
updated_user = User.objects.get(twitter_id=12552)
self.assertEqual(result['account'], 'bob')
self.assertIsInstance(result['user'], User)
self.assertEqual(result['user'].screen_name, 'philgyford')
self.assertEqual(updated_user.screen_name, 'philgyford')
self.assertEqual(1, len(responses.calls))
self.assertEqual(
'%s/%s.json' % (self.api_url, 'account/verify_credentials'),
responses.calls[0].request.url)
def test_get_absolute_url(self):
user = UserFactory(screen_name='bob')
self.assertEqual(user.get_absolute_url(), '/twitter/bob/')
def test_str(self):
"Has the correct string represntation"
user = UserFactory(screen_name='bill')
self.assertEqual(user.__str__(), '@bill')
def test_get_absolute_url(self):
user = UserFactory(screen_name='bob')
self.assertEqual(user.get_absolute_url(), '/twitter/bob/')
def test_unique_twitter_id(self):
"Ensures twitter_id is unique"
user_1 = UserFactory(twitter_id=123)
with self.assertRaises(IntegrityError):
user_2 = UserFactory(twitter_id=123)
def test_favorites_count(self):
user = UserFactory(favourites_count=37)
self.assertEqual(user.favorites_count, 37)
def test_profile_image_url(self):
url = 'https://twitter.com/tester.jpg'
user = UserFactory(profile_image_url_https=url)
self.assertEqual(user.profile_image_url, url)