def test_syncs_tags(self):
"""If a photo already has some tags, and we save_tags, the final set
of tags should match the new set of tags, deleting unused
relationships."""
photo_info_data = self.load_fixture('photos.getInfo')['photo']
user_1 = UserFactory(nsid="35034346050@N01")
user_2 = UserFactory(nsid="12345678901@N01")
photo = PhotoFactory(user=user_1)
# Create an initial tag on the photo.
tag = Tag.objects.create(slug='initial', name='Initial')
tagged_photo = Photo.tags.through(
flickr_id='12345', author=user_1, content_object=photo, tag=tag)
tagged_photo.save()
tag_slugs = photo.tags.slugs()
# Check starting state:
self.assertIn('initial', tag_slugs)
self.assertEqual(len(tag_slugs), 1)
# Save new tags:
PhotoSaver()._save_tags(photo, photo_info_data['tags']['tag'])
tag_slugs = photo.tags.slugs()
# Check that first tag has gone and the rest are there:
self.assertNotIn('initial', tag_slugs)
self.assertEqual(len(tag_slugs), 7)
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 test_creates_tags(self):
"""Saving tags should create all the tags and tagged_photos' data."""
photo_info_data = self.load_fixture('photos.getInfo')['photo']
user_1 = UserFactory(nsid="35034346050@N01")
user_2 = UserFactory(nsid="12345678901@N01")
photo = PhotoFactory(user=user_1)
PhotoSaver()._save_tags(photo, photo_info_data['tags']['tag'])
tags = photo.tags.all()
tagged_photos = TaggedPhoto.objects.filter(content_object=photo)
# Check we've saved both tags and the through model objects.
self.assertEqual(len(tags), 7)
self.assertEqual(len(tagged_photos), 7)
# Check we've saved all the stuff on the through model correctly.
for tp in tagged_photos:
if tp.tag.slug == 'abbeydore':
self.assertEqual(tp.tag.name, 'Abbey Dore')
self.assertFalse(tp.machine_tag)
self.assertEqual(tp.author, user_2)
self.assertEqual(tp.flickr_id, '5827-26069027966-1200699')
else:
self.assertEqual(tp.author, user_1)
if tp.tag.slug == 'tester:foo=bar':
self.assertTrue(tp.machine_tag)
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):
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 test_fetches_photo_info(self):
"""Fetches info for a photo, and no user info if they're all in
fetched_users"""
self.expect_response('photos.getInfo')
photo_data = self.load_fixture('photos.getInfo')['photo']
# Both users listed as authors of the tags in the fixture:
self.fetcher.fetched_users = {
'12345678901@N01': UserFactory(),
'35034346050@N01': UserFactory(),
}
results = self.fetcher._fetch_photo_info('26069027966')
self.assertEqual(results, photo_data)
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_permalink(self):
"Should point to the correct Flickr.com page"
photoset = PhotosetFactory(user=UserFactory(nsid='1234567890@N01'),
flickr_id='12345')
self.assertEqual(
photoset.permalink,
'https://www.flickr.com/photos/1234567890@N01/albums/12345')
def test_updates_existing_photo(self, save_tags):
"""Passing save_photo() data from the API should update an existing
Photo.
"""
# Some data that will be updated:
existing_photo = Photo(
flickr_id="26069027966",
user=UserFactory(),
secret='1234567890',
license='7',
farm=1,
safety_level=3,
title="An abbey",
description="A description",
is_private=True,
medium_width=300,
medium_height=200,
exif_camera='Sony')
existing_photo.save()
photo_data = self.make_photo_data()
photo = self.make_photo_object( photo_data )
self.assertEqual(photo.secret, 'abcd123456')
self.assertEqual(photo.license,'1')
self.assertEqual(photo.farm, 2)
self.assertEqual(photo.safety_level, 0)
self.assertEqual(photo.title, 'Dore Abbey')
self.assertEqual(photo.summary, "Some test HTML. And another paragraph.")
self.assertEqual(photo.description,
"Some <b>test HTML</b>.\n\nAnd another paragraph.")
self.assertFalse(photo.is_private)
self.assertEqual(photo.medium_width, 500)
self.assertEqual(photo.medium_height, 387)
self.assertEqual(photo.exif_camera, 'Sony NEX-6')
def test_fetch_user_if_missing_doesnt_fetch(self, save_user):
"""If the user is in fetched_users, it doesn't fetch the data again."""
# self.expect_response('people.getInfo')
user_data = self.load_fixture('people.getInfo')['person']
self.fetcher.fetched_users = {'35034346050@N01': UserFactory()}
self.fetcher._fetch_user_if_missing('35034346050@N01')
self.assertFalse(save_user.called)
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())
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_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')
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_photo_detail_privacy(self):
"It does not show private Photos"
user = UserFactory()
photo = PhotoFactory(is_private=True)
response = self.client.get(reverse('flickr:photo_detail',
kwargs={'nsid': user.nsid,
'flickr_id': photo.flickr_id}))
self.assertEqual(response.status_code, 404)
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_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_404(self):
"Should 404 with mis-matched user and photo IDs"
response = self.client.get(
reverse('flickr:photo_detail',
kwargs={
'nsid': UserFactory().nsid,
'flickr_id': PhotoFactory().flickr_id
}))
self.assertEqual(response.status_code, 404)
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 make_photoset_data(self):
"""Makes the dict of data that photo_save() expects, based on API data.
"""
return {
'fetch_time': datetime.datetime.utcnow().replace(tzinfo=pytz.utc),
'user_obj': UserFactory(nsid='35034346050@N01'),
'photoset': self.load_fixture('photosets.getList')['photosets']['photoset'][0],
'photos': self.load_fixture('photosets.getPhotos')['photoset']['photo'],
}
def make_photo_data(self):
"""Makes the dict of data that photo_save() expects, based on API data.
"""
return {
'fetch_time': datetime.datetime.utcnow().replace(tzinfo=pytz.utc),
'user_obj': UserFactory(nsid='35034346050@N01'),
'info': self.load_fixture('photos.getInfo')['photo'],
'exif': self.load_fixture('photos.getExif')['photo'],
'sizes': self.load_fixture('photos.getSizes')['sizes'],
}
def test_user_detail_privacy(self):
"It doesn't show private photos."
user = UserFactory()
public_photo = PhotoFactory(user=user)
private_photo = PhotoFactory(user=user, is_private=True)
response = self.client.get(
reverse('flickr:user_detail', kwargs={'nsid': user.nsid}))
self.assertIn('photo_list', response.context)
self.assertEqual(len(response.context['photo_list']), 1)
self.assertIn(public_photo, response.context['photo_list'])
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):
"Set the value of this setting that's used in ditto.flickr.models."
super().setUp()
self.default_use_local = app_settings.DITTO_FLICKR_USE_LOCAL_MEDIA
app_settings.DITTO_FLICKR_USE_LOCAL_MEDIA = True
self.photo = PhotoFactory(
user=UserFactory(nsid='123456@N01'),
taken_time=datetime.datetime.strptime(
'2015-08-14 12:00:00',
'%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.utc))
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_fetches_photo_info_and_tag_user(self, fetch_avatar):
"""Fetches info for a photo and any tag authors who aren't in
fetched_users."""
self.expect_response('photos.getInfo')
self.expect_response('people.getInfo')
photo_data = self.load_fixture('photos.getInfo')['photo']
# One user listed as a tag author isn't in fetched_users:
self.fetcher.fetched_users = {
'12345678901@N01': UserFactory(),
}
results = self.fetcher._fetch_photo_info('26069027966')
self.assertEqual(results, photo_data)
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_photo_detail_context_no_account(self):
"Sends correct data to templates when showing a photo with no account"
user = UserFactory()
photos = PhotoFactory.create_batch(3, user=user)
response = self.client.get(reverse('flickr:photo_detail',
kwargs={'nsid': user.nsid,
'flickr_id': photos[1].flickr_id}))
self.assertIn('account', response.context)
self.assertIsNone(response.context['account'])
self.assertIn('flickr_user', response.context)
self.assertEqual(user.pk, response.context['flickr_user'].pk)
self.assertIn('photo', response.context)
self.assertEqual(photos[1].pk, response.context['photo'].pk)
def test_fetch_user_if_missing_fetches(self, save_user, fetch_avatar):
"""If the user isn't in fetched_users, it is fetched and saved."""
save_user.return_value = UserFactory.create(nsid='35034346050@N01')
self.expect_response('people.getInfo')
user_data = self.load_fixture('people.getInfo')['person']
self.fetcher._fetch_user_if_missing('35034346050@N01')
save_user.assert_called_once_with(user_data, datetime_now())
self.assertEqual(1, len(self.fetcher.fetched_users))
self.assertEqual(self.fetcher.fetched_users['35034346050@N01'].nsid,
'35034346050@N01')
def test_fetch_user_if_missing_fetches(self, save_user, fetch_avatar):
"""If the user isn't in fetched_users, it is fetched and saved."""
save_user.return_value = UserFactory.create(nsid='35034346050@N01')
self.expect_response('people.getInfo')
user_data = self.load_fixture('people.getInfo')['person']
self.fetcher._fetch_user_if_missing('35034346050@N01')
save_user.assert_called_once_with(user_data, datetime_now())
self.assertEqual(1, len(self.fetcher.fetched_users))
self.assertEqual(self.fetcher.fetched_users['35034346050@N01'].nsid,
'35034346050@N01')
