def setUp(self):
user_1 = UserFactory(nsid='1234567890@N01')
user_2 = UserFactory(nsid='9876543210@N01')
account_1 = AccountFactory(user=user_1)
account_2 = AccountFactory(user=user_2)
self.photosets_1 = PhotosetFactory.create_batch(2, user=user_1)
self.photosets_2 = PhotosetFactory.create_batch(3, user=user_2)
def setUp(self):
user = UserFactory()
account = AccountFactory(user=user)
self.photo_1 = PhotoFactory(
user=user,
post_time=datetime.datetime.strptime(
'2016-04-08 12:00:00',
'%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.utc))
self.private_photo = PhotoFactory(
user=user,
is_private=True,
post_time=datetime.datetime.strptime(
'2016-04-09 12:00:00',
'%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.utc))
# Photo by a different user:
user_2 = UserFactory()
account_2 = AccountFactory(user=user_2)
self.other_photo = PhotoFactory(
user=user_2,
post_time=datetime.datetime.strptime(
'2016-04-10 12:00:00',
'%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.utc))
self.photo_2 = PhotoFactory(
user=user,
post_time=datetime.datetime.strptime(
'2016-04-11 12:00:00',
'%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.utc))
def setUp(self):
self.account_1 = AccountFactory(api_key='1234', api_secret='9876',
user=UserFactory(nsid='35034346050@N01') )
self.inactive_account = AccountFactory(
api_key='2345', api_secret='8765', is_active=False,
user=UserFactory(nsid='12345678901@N01') )
self.account_2 = AccountFactory(api_key='3456', api_secret='7654',
user=UserFactory(nsid='98765432101@N01') )
class MultiAccountFetcherTestCase(FlickrFetchTestCase):
def setUp(self):
self.account_1 = AccountFactory(
api_key='1234',
api_secret='9876',
user=UserFactory(nsid='35034346050@N01'))
self.inactive_account = AccountFactory(
api_key='2345',
api_secret='8765',
is_active=False,
user=UserFactory(nsid='12345678901@N01'))
self.account_2 = AccountFactory(
api_key='3456',
api_secret='7654',
user=UserFactory(nsid='98765432101@N01'))
def tearDown(self):
pass
def test_inherits_from_multi_account_fetcher(self):
self.assertTrue(
issubclass(RecentPhotosMultiAccountFetcher, MultiAccountFetcher))
def test_fetch_throws_exception(self):
"Throws an exception if its own fetch() method is called."
with self.assertRaises(FetchError):
MultiAccountFetcher().fetch()
def test_uses_all_accounts_by_default(self):
fetcher = MultiAccountFetcher()
self.assertEqual(len(fetcher.accounts), 2)
def test_throws_exception_with_no_active_accounts(self):
self.account_1.is_active = False
self.account_2.is_active = False
self.account_1.save()
self.account_2.save()
with self.assertRaises(FetchError):
MultiAccountFetcher()
def test_throws_exception_with_invalid_nsid(self):
with self.assertRaises(FetchError):
MultiAccountFetcher(nsid='nope')
def test_throws_exception_with_no_account(self):
"If the NSID is not attached to an Account."
user = UserFactory(nsid='99999999999@N01')
with self.assertRaises(FetchError):
MultiAccountFetcher(nsid='99999999999@N01')
def test_throws_exception_with_inactive_account(self):
with self.assertRaises(FetchError):
MultiAccountFetcher(nsid='12345678901@N01')
def test_works_with_valid_nsid(self):
fetcher = MultiAccountFetcher(nsid='35034346050@N01')
self.assertEqual(len(fetcher.accounts), 1)
self.assertEqual(fetcher.accounts[0], self.account_1)
class MultiAccountFetcherTestCase(FlickrFetchTestCase):
def setUp(self):
self.account_1 = AccountFactory(api_key='1234', api_secret='9876',
user=UserFactory(nsid='35034346050@N01') )
self.inactive_account = AccountFactory(
api_key='2345', api_secret='8765', is_active=False,
user=UserFactory(nsid='12345678901@N01') )
self.account_2 = AccountFactory(api_key='3456', api_secret='7654',
user=UserFactory(nsid='98765432101@N01') )
def tearDown(self):
pass
def test_inherits_from_multi_account_fetcher(self):
self.assertTrue(
issubclass(RecentPhotosMultiAccountFetcher, MultiAccountFetcher)
)
def test_fetch_throws_exception(self):
"Throws an exception if its own fetch() method is called."
with self.assertRaises(FetchError):
MultiAccountFetcher().fetch()
def test_uses_all_accounts_by_default(self):
fetcher = MultiAccountFetcher()
self.assertEqual(len(fetcher.accounts), 2)
def test_throws_exception_with_no_active_accounts(self):
self.account_1.is_active = False
self.account_2.is_active = False
self.account_1.save()
self.account_2.save()
with self.assertRaises(FetchError):
MultiAccountFetcher()
def test_throws_exception_with_invalid_nsid(self):
with self.assertRaises(FetchError):
MultiAccountFetcher(nsid='nope')
def test_throws_exception_with_no_account(self):
"If the NSID is not attached to an Account."
user = UserFactory(nsid='99999999999@N01')
with self.assertRaises(FetchError):
MultiAccountFetcher(nsid='99999999999@N01')
def test_throws_exception_with_inactive_account(self):
with self.assertRaises(FetchError):
MultiAccountFetcher(nsid='12345678901@N01')
def test_works_with_valid_nsid(self):
fetcher = MultiAccountFetcher(nsid='35034346050@N01')
self.assertEqual(len(fetcher.accounts), 1)
self.assertEqual(fetcher.accounts[0], self.account_1)
def setUp(self):
user_1 = UserFactory(nsid='1234567890@N01')
user_2 = UserFactory(nsid='9876543210@N01')
account_1 = AccountFactory(user=user_1)
account_2 = AccountFactory(user=user_2)
self.photos_1 = PhotoFactory.create_batch(2, user=user_1)
self.photos_2 = PhotoFactory.create_batch(3, user=user_2)
self.private_photo = PhotoFactory(user=user_1, is_private=True)
# For comparing with the results:
self.public_pks = [p.pk for p in self.photos_1] + \
[p.pk for p in self.photos_2]
def setUp(self):
# What we'll use as return values from UserIdFetcher().fetch()...
self.id_fetcher_success =\
{'success': True, 'id': '35034346050@N01', 'fetched': 1}
# ...and UserFetcher().fetch():
self.user_fetcher_success =\
{'success': True, 'user': {'name': 'Phil Gyford'}, 'fetched': 1}
self.account = AccountFactory(id=32, user=None)
self.out = StringIO()
self.out_err = StringIO()
def setUp(self):
self.account_1 = AccountFactory(
api_key='1234',
api_secret='9876',
user=UserFactory(nsid='35034346050@N01'))
self.inactive_account = AccountFactory(
api_key='2345',
api_secret='8765',
is_active=False,
user=UserFactory(nsid='12345678901@N01'))
self.account_2 = AccountFactory(
api_key='3456',
api_secret='7654',
user=UserFactory(nsid='98765432101@N01'))
def test_with_unsaved_account(self):
"""If Account is unsaved, should set 'account' value appropriately."""
account = AccountFactory.build(user=None)
result = Fetcher(account=account).fetch()
self.assertFalse(result['success'])
self.assertIn('messages', result)
self.assertEqual(result['account'], 'Unsaved Account')
def test_returns_false_with_no_creds(self):
"""Success is false if Account has no API credentials"""
account = AccountFactory(user=UserFactory(username='******'))
result = Fetcher(account=account).fetch()
self.assertFalse(result['success'])
self.assertIn('messages', result)
self.assertEqual(result['account'], 'bob')
def test_with_unsaved_account(self):
"""If Account is unsaved, should set 'account' value appropriately."""
account = AccountFactory.build(user=None)
result = Fetcher(account=account).fetch()
self.assertFalse(result['success'])
self.assertIn('messages', result)
self.assertEqual(result['account'], 'Unsaved Account')
def test_account_with_no_user(self):
"""If Account has no user should set 'account' value appropriately."""
account = AccountFactory(user=None)
result = Fetcher(account=account).fetch()
self.assertFalse(result['success'])
self.assertIn('messages', result)
self.assertEqual(result['account'], 'Account: 1')
def test_failure_with_no_child_save_results(self, call_api):
"""Requires a child class to set its own _call_api()."""
account = AccountFactory(user=UserFactory(username='******'),
api_key='1234',
api_secret='9876')
result = Fetcher(account=account).fetch()
self.assertFalse(result['success'])
self.assertIn('messages', result)
def test_user_detail_templates(self):
"Uses the correct templates"
account = AccountFactory()
response = self.client.get(
reverse('flickr:user_detail', kwargs={'nsid': account.user.nsid}))
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'flickr/user_detail.html')
self.assertTemplateUsed(response, 'flickr/base.html')
self.assertTemplateUsed(response, 'ditto/base.html')
def setUp(self):
user_1 = UserFactory(nsid='1234567890@N01')
user_2 = UserFactory(nsid='9876543210@N01')
account_1 = AccountFactory(user=user_1)
account_2 = AccountFactory(user=user_2)
self.photos_1 = PhotoFactory.create_batch(2, user=user_1)
self.photos_2 = PhotoFactory.create_batch(3, user=user_2)
post_time = datetime.datetime(2015, 3, 18, 12, 0,
0).replace(tzinfo=pytz.utc)
self.photos_1[0].post_time = post_time
self.photos_1[0].save()
self.photos_2[1].post_time = post_time + datetime.timedelta(hours=1)
self.photos_2[1].save()
self.private_photo = PhotoFactory(user=user_1,
is_private=True,
post_time=post_time)
def test_returns_true_with_creds(self, save_results, call_api):
"""Success is true if Account has API credentials"""
account = AccountFactory(user=UserFactory(username='******'),
api_key='1234',
api_secret='9876')
result = Fetcher(account=account).fetch()
self.assertEqual(result['account'], 'terry')
self.assertTrue(result['success'])
self.assertEqual(result['fetched'], 0)
def test_returns_false_when_extra_data_fetching_fails(
self, call_api, fetch_extra):
fetch_extra.side_effect = FetchError('Oh dear')
account = AccountFactory(user=UserFactory(username='******'),
api_key='1234',
api_secret='9876')
result = Fetcher(account=account).fetch()
self.assertFalse(result['success'])
self.assertIn('Oh dear', result['messages'][0])
def test_home_privacy(self):
"Only public Photos should appear."
# We only display Photos from Accounts, so add some.
user_1 = UserFactory()
user_2 = UserFactory()
account_1 = AccountFactory(user=user_1)
account_2 = AccountFactory(user=user_2)
public_photo_1 = PhotoFactory(user=user_1)
private_photo_1 = PhotoFactory(user=user_1, is_private=True)
public_photo_2 = PhotoFactory(user=user_2)
private_photo_2 = PhotoFactory(user=user_2, is_private=True)
response = self.client.get(reverse('flickr:home'))
photos = response.context['photo_list']
self.assertEqual(len(photos), 2)
self.assertEqual(photos[0].pk, public_photo_1.pk)
self.assertEqual(photos[1].pk, public_photo_2.pk)
def test_photo_detail_templates(self):
"Uses the correct templates"
account = AccountFactory()
photos = PhotoFactory.create_batch(3, user=account.user)
response = self.client.get(reverse('flickr:photo_detail',
kwargs={'nsid': account.user.nsid,
'flickr_id': photos[1].flickr_id}))
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'flickr/photo_detail.html')
self.assertTemplateUsed(response, 'flickr/base.html')
self.assertTemplateUsed(response, 'ditto/base.html')
def test_public_photos_manager(self):
"Returns ONLY public photos, ONLY by an Account."
user = UserFactory()
account = AccountFactory(user=user)
public_photo = PhotoFactory(is_private=False)
public_photo_by_account = PhotoFactory(is_private=False, user=user)
private_photo = PhotoFactory(is_private=True)
private_photo_by_account = PhotoFactory(is_private=True, user=user)
photos = Photo.public_photo_objects.all()
self.assertEqual(len(photos), 1)
self.assertEqual(photos[0], public_photo_by_account)
def setUp(self):
self.user_1 = UserFactory(nsid='1234567890@N01')
self.user_2 = UserFactory(nsid='9876543210@N01')
AccountFactory(user=self.user_1)
AccountFactory(user=self.user_2)
# Photos taken in 2015 and 2016 for user 1:
PhotoFactory.create_batch(
3,
taken_time=datetime_from_str('2015-01-01 12:00:00'),
user=self.user_1)
PhotoFactory.create_batch(
2,
taken_time=datetime_from_str('2016-01-01 12:00:00'),
user=self.user_1)
# And one for user_2 taken in 2015:
PhotoFactory(user=self.user_2,
taken_time=datetime_from_str('2015-01-01 12:00:00'))
# And one private photo for user_1 taken in 2015:
PhotoFactory(user=self.user_1,
is_private=True,
taken_time=datetime_from_str('2015-01-01 12:00:00'))
def test_photos_manager(self):
"Returns public AND private photos ONLY by an Account."
user = UserFactory()
account = AccountFactory(user=user)
public_photo = PhotoFactory(is_private=False)
public_photo_by_account = PhotoFactory(is_private=False, user=user)
private_photo = PhotoFactory(is_private=True)
private_photo_by_account = PhotoFactory(is_private=True, user=user)
photos = Photo.photo_objects.all()
self.assertEqual(len(photos), 2)
self.assertIn(public_photo_by_account, photos)
self.assertIn(private_photo_by_account, photos)
def test_home_ordering_posted(self):
"By default, photos should be in reverse-post_time order."
dt = datetime_now()
ac = AccountFactory()
photo_1 = PhotoFactory(user=ac.user, post_time=dt - timedelta(days=1))
photo_3 = PhotoFactory(user=ac.user, post_time=dt - timedelta(days=3))
photo_2 = PhotoFactory(user=ac.user, post_time=dt - timedelta(days=2))
response = self.client.get(reverse('flickr:home'))
pl = response.context['photo_list']
self.assertEqual(pl[0].pk, photo_1.pk)
self.assertEqual(pl[1].pk, photo_2.pk)
self.assertEqual(pl[2].pk, photo_3.pk)
def test_photo_detail_context(self):
"Sends the correct data to templates"
account = AccountFactory()
photos = PhotoFactory.create_batch(3, user=account.user)
response = self.client.get(reverse('flickr:photo_detail',
kwargs={'nsid': account.user.nsid,
'flickr_id': photos[1].flickr_id}))
self.assertIn('account', response.context)
self.assertEqual(account.pk, response.context['account'].pk)
self.assertIn('flickr_user', response.context)
self.assertEqual(account.user.pk, response.context['flickr_user'].pk)
self.assertIn('photo', response.context)
self.assertEqual(photos[1].pk, response.context['photo'].pk)
def test_user_detail_ordering_posted(self):
"By default, photos should be in reverse-post_time order."
dt = datetime_now()
user = UserFactory()
ac = AccountFactory(user=user)
photo_1 = PhotoFactory(user=user, post_time=dt - timedelta(days=1))
photo_3 = PhotoFactory(user=user, post_time=dt - timedelta(days=3))
photo_2 = PhotoFactory(user=user, post_time=dt - timedelta(days=2))
response = self.client.get(
reverse('flickr:user_detail', kwargs={'nsid': user.nsid}))
pl = response.context['photo_list']
self.assertEqual(pl[0].pk, photo_1.pk)
self.assertEqual(pl[1].pk, photo_2.pk)
self.assertEqual(pl[2].pk, photo_3.pk)
def setUp(self):
self.user_1 = UserFactory(nsid='1234567890@N01')
self.account_1 = AccountFactory(user=self.user_1)
# Three photos, one of which is private.
self.photos_1 = PhotoFactory.create_batch(3, user=self.user_1)
self.photos_1[0].is_private = True
self.photos_1[0].save()
self.user_2 = UserFactory(nsid='9876543210@N01')
self.account_2 = AccountFactory(user=self.user_2)
self.photos_2 = PhotoFactory.create_batch(3, user=self.user_2)
# Has three photos, one of them private:
self.photoset_1 = PhotosetFactory(user=self.user_1, flickr_id=123456)
self.photoset_1.photos.add(*self.photos_1)
# Should have two of user_2's three photos:
self.photoset_2a = PhotosetFactory(user=self.user_2, flickr_id=98765)
self.photoset_2a.photos.add(self.photos_2[0], self.photos_2[1])
# Has all three of user_2's photos:
self.photoset_2b = PhotosetFactory(user=self.user_2, flickr_id=55555)
self.photoset_2b.photos.add(*self.photos_2)
def test_home_ordering_taken(self):
"""With ?order=taken, photos should be in reverse-taken_time order.
And Photos with taken_unknown=True should not appear."""
dt = datetime_now()
ac = AccountFactory()
photo_1 = PhotoFactory(user=ac.user, taken_time=dt - timedelta(days=1))
photo_3 = PhotoFactory(user=ac.user, taken_time=dt - timedelta(days=3))
photo_2 = PhotoFactory(user=ac.user, taken_time=dt - timedelta(days=2))
photo_4 = PhotoFactory(user=ac.user, taken_unknown=True)
response = self.client.get(reverse('flickr:home') + '?order=taken')
pl = response.context['photo_list']
self.assertEqual(len(pl), 3)
self.assertEqual(pl[0].pk, photo_1.pk)
self.assertEqual(pl[1].pk, photo_2.pk)
self.assertEqual(pl[2].pk, photo_3.pk)
def test_home_context(self):
"The Flickr home page sends the correct data to templates"
accounts = AccountFactory.create_batch(3)
photos_1 = PhotoFactory.create_batch(2, user=accounts[0].user)
photos_2 = PhotoFactory.create_batch(2, user=accounts[1].user)
response = self.client.get(reverse('flickr:home'))
self.assertIn('account_list', response.context)
self.assertIn('photo_list', response.context)
self.assertEqual(len(response.context['photo_list']), 4)
self.assertIn('order', response.context)
self.assertEqual(response.context['order'], 'uploaded')
# Three accounts, only two of which have Photos:
self.assertEqual(
[account.pk for account in response.context['account_list']],
[1, 2, 3])
def test_home_context(self):
"The Flickr home page sends the correct data to templates"
accounts = AccountFactory.create_batch(3)
photos_1 = PhotoFactory.create_batch(2, user=accounts[0].user)
photos_2 = PhotoFactory.create_batch(2, user=accounts[1].user)
response = self.client.get(reverse('flickr:home'))
self.assertIn('account_list', response.context)
self.assertIn('photo_list', response.context)
self.assertEqual(len(response.context['photo_list']), 4)
self.assertIn('order', response.context)
self.assertEqual(response.context['order'], 'uploaded')
# Three accounts, only two of which have Photos:
self.assertEqual(
[account.pk for account in response.context['account_list']],
[1,2,3]
)
def test_tag_detail_context(self):
"Sends the correct data to the templates"
accounts = AccountFactory.create_batch(2)
# The 'fish' tag page shouldn't include this dog photo:
self.createDogPhoto()
response = self.client.get(
reverse('flickr:tag_detail', kwargs={'slug': 'fish'}))
self.assertIn('account_list', response.context)
self.assertEqual(
[account.pk for account in response.context['account_list']],
[1, 2])
self.assertIn('tag', response.context)
self.assertEqual(response.context['tag'].slug, 'fish')
self.assertIn('order', response.context)
self.assertEqual(response.context['order'], 'uploaded')
self.assertIn('photo_list', response.context)
self.assertEqual(len(response.context['photo_list']), 2)
self.assertEqual(response.context['photo_list'][0].title, 'Carp')
self.assertEqual(response.context['photo_list'][1].title, 'Cod')
def test_tag_detail_context(self):
"Sends the correct data to the templates"
accounts = AccountFactory.create_batch(2)
# The 'fish' tag page shouldn't include this dog photo:
self.createDogPhoto()
response = self.client.get(reverse('flickr:tag_detail',
kwargs={'slug': 'fish'}))
self.assertIn('account_list', response.context)
self.assertEqual(
[account.pk for account in response.context['account_list']],
[1,2]
)
self.assertIn('tag', response.context)
self.assertEqual(response.context['tag'].slug, 'fish')
self.assertIn('order', response.context)
self.assertEqual(response.context['order'], 'uploaded')
self.assertIn('photo_list', response.context)
self.assertEqual(len(response.context['photo_list']), 2)
self.assertEqual(response.context['photo_list'][0].title, 'Carp')
self.assertEqual(response.context['photo_list'][1].title, 'Cod')
def test_user_detail_context_with_account(self):
"Sends correct data to templates for a User with an Account."
user = UserFactory()
account = AccountFactory(user=user)
users_photos = PhotoFactory.create_batch(2, user=user)
other_photos = PhotoFactory.create_batch(2)
response = self.client.get(
reverse('flickr:user_detail', kwargs={'nsid': user.nsid}))
self.assertIn('account', response.context)
self.assertEqual(response.context['account'], account)
self.assertIn('flickr_user', response.context)
self.assertEqual(user.pk, response.context['flickr_user'].pk)
self.assertIn('order', response.context)
self.assertEqual(response.context['order'], 'uploaded')
self.assertIn('photo_list', response.context)
self.assertEqual(len(response.context['photo_list']), 2)
# ie, only user's photos.
self.assertIn(users_photos[0], response.context['photo_list'])
self.assertIn(users_photos[1], response.context['photo_list'])
def setUp(self):
user = UserFactory()
account = AccountFactory(user=user)
self.fetcher = OriginalFilesFetcher(account=account)
self.photo_1 = PhotoFactory(title='p1',
original_file='p1.jpg',
user=user)
the_time = datetime.datetime.strptime(
'2015-08-14', '%Y-%m-%d').replace(tzinfo=pytz.utc)
# Needs a taken_time for testing file save path:
# post_time will put them in order.
self.photo_2 = PhotoFactory(title='p2',
original_file=None,
user=user,
post_time=the_time,
taken_time=the_time)
self.video_1 = PhotoFactory(title='v1',
media='video',
original_file='v1.jpg',
video_original_file='v1.mov',
user=user)
self.video_2 = PhotoFactory(title='v2',
media='video',
original_file=None,
video_original_file=None,
user=user,
flickr_id='1234567890',
original_secret='7777',
post_time=the_time,
taken_time=the_time)
# And one by someone else:
self.photo_3 = PhotoFactory(title='p3',
original_file=None,
user=UserFactory())
def test_fails_with_no_flickr_user(self):
fetcher = OriginalFilesFetcher(account=AccountFactory(user=None))
results = fetcher.fetch()
self.assertFalse(results['success'])
self.assertIn('This account has no Flickr User',
results['messages'][0])
class FetchFlickrAccountUserTestCase(TestCase):
def setUp(self):
# What we'll use as return values from UserIdFetcher().fetch()...
self.id_fetcher_success =\
{'success': True, 'id': '35034346050@N01', 'fetched': 1}
# ...and UserFetcher().fetch():
self.user_fetcher_success =\
{'success': True, 'user': {'name': 'Phil Gyford'}, 'fetched': 1}
self.account = AccountFactory(id=32, user=None)
self.out = StringIO()
self.out_err = StringIO()
def test_fail_with_no_args(self):
with self.assertRaises(CommandError):
call_command('fetch_flickr_account_user')
def test_fail_with_invalid_id(self):
call_command('fetch_flickr_account_user', id='3', stderr=self.out_err)
self.assertIn("No Account found with an id of '3'",
self.out_err.getvalue())
@patch('ditto.flickr.management.commands.fetch_flickr_account_user.UserFetcher')
@patch('ditto.flickr.management.commands.fetch_flickr_account_user.UserIdFetcher')
def test_with_id(self, id_fetcher, user_fetcher):
user = UserFactory(nsid='35034346050@N01')
id_fetcher.return_value.fetch.return_value = self.id_fetcher_success
user_fetcher.return_value.fetch.return_value = self.user_fetcher_success
call_command('fetch_flickr_account_user', id='32', stdout=self.out)
self.assertIn("Fetched and saved user 'Phil Gyford'",
self.out.getvalue())
@patch('ditto.flickr.management.commands.fetch_flickr_account_user.UserFetcher')
@patch('ditto.flickr.management.commands.fetch_flickr_account_user.UserIdFetcher')
def test_invalid_nsid(self, id_fetcher, user_fetcher):
"""
Correct error message if we fail to find a user for the fetched
Flickr ID (unlikely).
"""
id_fetcher.return_value.fetch.return_value = self.id_fetcher_success
user_fetcher.return_value.fetch.return_value =\
{'success': False, 'messages': ['Oops']}
call_command('fetch_flickr_account_user', id='32', stderr=self.out_err)
self.assertIn(
"Failed to fetch a user using Flickr ID '35034346050@N01': Oops",
self.out_err.getvalue())
@patch('ditto.flickr.management.commands.fetch_flickr_account_user.UserIdFetcher')
def test_no_matching_nsid(self, id_fetcher):
"Correct error message if we can't find a Flickr ID for this Account."
id_fetcher.return_value.fetch.return_value =\
{'success': False, 'messages': ['Oops']}
call_command('fetch_flickr_account_user', id='32', stderr=self.out_err)
self.assertIn(
"Failed to fetch a Flickr ID for this Account: Oops",
self.out_err.getvalue())
@patch('ditto.flickr.management.commands.fetch_flickr_account_user.UserFetcher')
@patch('ditto.flickr.management.commands.fetch_flickr_account_user.UserIdFetcher')
def test_associates_account_with_user(self, id_fetcher, user_fetcher):
"After fetching and saving the user, associate it with the Account."
user = UserFactory(nsid='35034346050@N01')
id_fetcher.return_value.fetch.return_value = self.id_fetcher_success
user_fetcher.return_value.fetch.return_value = self.user_fetcher_success
call_command('fetch_flickr_account_user', id='32', stdout=self.out)
self.account.refresh_from_db()
self.assertEqual(self.account.user.nsid, '35034346050@N01')
