def test_safety_level_str(self):
photo = PhotoFactory(safety_level=0)
self.assertEqual(photo.safety_level_str, 'None')
photo.safety_level = 2
self.assertEqual(photo.safety_level_str, 'Moderate')
photo.safety_level = 99
self.assertIsNone(photo.safety_level_str)
def test_public_manager_recent(self):
"The public manager ONLY includes public photos."
public_photo = PhotoFactory(is_private=False)
private_photo = PhotoFactory(is_private=True)
photos = Photo.public_objects.all()
self.assertEqual(len(photos), 1)
self.assertEqual(photos[0], public_photo)
def test_public_photos(self):
"public_photos() should only return public photos."
public_photo = PhotoFactory(is_private=False)
private_photo = PhotoFactory(is_private=True)
photoset = PhotosetFactory()
photoset.photos.add(public_photo, private_photo)
self.assertEqual(len(photoset.public_photos()), 1)
self.assertEqual(photoset.public_photos()[0], public_photo)
def createDogPhoto(self):
"Creates a photo tagged with 'dog' and 'mammal'."
self.dog_photo = PhotoFactory(title='Dog')
mammal_tag = TagFactory(slug='mammal')
dog_tag = TagFactory(slug='dog')
taggedphoto_5 = TaggedPhotoFactory(content_object=self.dog_photo,
tag=mammal_tag)
taggedphoto_6 = TaggedPhotoFactory(content_object=self.dog_photo,
tag=dog_tag)
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_photo_ordering(self):
"Should return photos in the correct order."
photo_1 = PhotoFactory()
photo_2 = PhotoFactory()
photo_3 = PhotoFactory()
photoset = PhotosetFactory()
photoset.photos.add(photo_2, photo_1, photo_3)
photos = photoset.photos.all()
self.assertEqual(photos[0], photo_2)
self.assertEqual(photos[1], photo_1)
self.assertEqual(photos[2], photo_3)
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):
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_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 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_data(self):
"Check format of a single data element."
user = FlickrUserFactory(nsid='35034346050@N01')
PhotoFactory.create_batch(3,
user=user,
post_time=make_datetime('2018-01-01 12:00:00'))
result = FlickrGenerator(nsid='35034346050@N01').get_photos_per_year()
self.assertIn('data', result)
self.assertEqual(len(result['data']), 1)
self.assertEqual(result['data'][0]['label'], '2018')
self.assertEqual(result['data'][0]['value'], 3)
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 test_ordering(self):
"Latest photo (uploaded) should come first by default."
photo_1 = PhotoFactory(
title='Earliest',
post_time=datetime.datetime.strptime(
'2016-04-07 12:00:00',
'%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.utc))
photo_2 = PhotoFactory(
title='Latest',
post_time=datetime.datetime.strptime(
'2016-04-08 12:00:00',
'%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.utc))
photos = Photo.objects.all()
self.assertEqual(photos[0].title, 'Latest')
self.assertEqual(photos[1].title, 'Earliest')
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_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_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 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 test_location_str(self):
photo = PhotoFactory(locality_name='Abbey Dore',
county_name='',
region_name='England',
country_name='United Kingdom')
self.assertEqual(photo.location_str,
'Abbey Dore, England, United Kingdom')
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_medium_url(self):
"Has a different format to most other image sizes."
photo = PhotoFactory(farm=3,
server='1234',
flickr_id=4567,
secret='9876')
self.assertEqual(photo.medium_url,
'https://farm3.static.flickr.com/1234/4567_9876.jpg')
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 test_adds_primary_photo(self):
"If the primary photo is in the DB, it's set."
photo = PhotoFactory(flickr_id=24990464004)
photoset_data = self.make_photoset_data()
photoset = self.make_photoset_object( photoset_data )
self.assertEqual(photoset.primary_photo, photo)
def createDogPhoto(self):
"Creates a photo tagged with 'dog' and 'mammal'."
self.dog_photo = PhotoFactory(title='Dog')
mammal_tag = TagFactory(slug='mammal')
dog_tag = TagFactory(slug='dog')
taggedphoto_5 = TaggedPhotoFactory(
content_object=self.dog_photo, tag=mammal_tag)
taggedphoto_6 = TaggedPhotoFactory(
content_object=self.dog_photo, tag=dog_tag)
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_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_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 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_empty_years(self):
"It should include years for which there are no photos."
# Add a photo in 2018, leaving a gap for 2017:
PhotoFactory(taken_time=datetime_from_str('2018-01-01 12:00:00'),
user=self.user_1)
photos = ditto_flickr.annual_photo_counts(count_by='taken_time')
self.assertEqual(len(photos), 4)
self.assertEqual(photos[2]['year'], 2017)
self.assertEqual(photos[2]['count'], 0)
class PhotoNextPrevTestCase(TestCase):
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 test_next_public_by_post_time(self):
self.assertEqual(self.photo_1.get_next_public_by_post_time(),
self.photo_2)
def test_next_public_by_post_time_none(self):
self.assertIsNone(self.photo_2.get_next_public_by_post_time())
def test_previous_public_by_post_time(self):
self.assertEqual(self.photo_2.get_previous_public_by_post_time(),
self.photo_1)
def test_previous_public_by_post_time_none(self):
self.assertIsNone(self.photo_1.get_previous_public_by_post_time())
def test_next(self):
self.assertEqual(self.photo_1.get_next(), self.photo_2)
def test_next_none(self):
self.assertIsNone(self.photo_2.get_next())
def test_previous(self):
self.assertEqual(self.photo_2.get_previous(), self.photo_1)
def test_previous_none(self):
self.assertIsNone(self.photo_1.get_previous())
def setUp(self):
"""
Creates two photos sharing three tags:
1 has 'fish' and 'carp' tags.
2 has 'fish' and 'cod' tags.
"""
self.carp_photo = PhotoFactory(title='Carp')
self.cod_photo = PhotoFactory(title='Cod')
fish_tag = TagFactory(slug='fish', name='Fish')
carp_tag = TagFactory(slug='carp', name='Carp')
cod_tag = TagFactory(slug='cod', name='Cod')
taggedphoto_1 = TaggedPhotoFactory(content_object=self.carp_photo,
tag=fish_tag)
taggedphoto_2 = TaggedPhotoFactory(content_object=self.carp_photo,
tag=carp_tag)
taggedphoto_3 = TaggedPhotoFactory(content_object=self.cod_photo,
tag=fish_tag)
taggedphoto_4 = TaggedPhotoFactory(content_object=self.cod_photo,
tag=cod_tag)
def setUp(self):
"""
Creates two photos sharing three tags:
1 has 'fish' and 'carp' tags.
2 has 'fish' and 'cod' tags.
"""
self.carp_photo = PhotoFactory(title='Carp')
self.cod_photo = PhotoFactory(title='Cod')
fish_tag = TagFactory(slug='fish', name='Fish')
carp_tag = TagFactory(slug='carp', name='Carp')
cod_tag = TagFactory(slug='cod', name='Cod')
taggedphoto_1 = TaggedPhotoFactory(
content_object=self.carp_photo, tag=fish_tag)
taggedphoto_2 = TaggedPhotoFactory(
content_object=self.carp_photo, tag=carp_tag)
taggedphoto_3 = TaggedPhotoFactory(
content_object=self.cod_photo, tag=fish_tag)
taggedphoto_4 = TaggedPhotoFactory(
content_object=self.cod_photo, tag=cod_tag)
def test_image_urls(self):
"""Test all but the Original and Medium image URL properties."""
photo = PhotoFactory(farm=3,
server='1234',
flickr_id=4567,
secret='9876')
for size, prop in self.photo_sizes.items():
self.assertEqual(
getattr(photo, prop),
'https://farm3.static.flickr.com/1234/4567_9876_%s.jpg' % size)
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_flickr_photos_several(self):
"It should return all Photos from each day."
user = UserFactory(nsid='11111111111@N01')
account = FlickrAccountFactory(user=user)
day_1_photos = PhotoFactory.create_batch(4,
user=user, is_private=False,
post_time=make_datetime('2017-05-01 12:30:00'))
day_2_photos = PhotoFactory.create_batch(3,
user=user, is_private=False,
post_time=make_datetime('2017-06-01 12:30:00'))
r = RecentObjects( (('flickr_photos', user.nsid,),) )
objects = r.get_objects()
self.assertEqual(len(objects), 2)
self.assertEqual(len(objects[0]['objects']), 3)
self.assertEqual(len(objects[1]['objects']), 4)
def test_remote_original_url(self):
"Should still return remote URL when we're using local photos."
photo = PhotoFactory(farm=3,
server='1234',
flickr_id=4567,
secret='9876',
original_secret='7777',
original_format='gif')
self.assertEqual(
photo.remote_original_url,
'https://farm3.static.flickr.com/1234/4567_7777_o.gif')
def test_remote_original_url(self):
"By default, same as photo.original_url."
photo = PhotoFactory(farm=3,
server='1234',
flickr_id=4567,
secret='9876',
original_secret='7777',
original_format='gif')
self.assertEqual(
photo.remote_original_url,
'https://farm3.static.flickr.com/1234/4567_7777_o.gif')
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 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)
taken_time = datetime.datetime(2014, 3, 18, 12, 0, 0).replace(
tzinfo=pytz.utc)
post_time = datetime.datetime(2015, 3, 18, 12, 0, 0).replace(
tzinfo=pytz.utc)
self.photos_1[0].taken_time = taken_time
self.photos_1[0].post_time = post_time
self.photos_1[0].save()
self.photos_2[1].taken_time = taken_time + datetime.timedelta(hours=1)
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_flickr_photos(self):
"It only returns Public Photos from the correct User"
u1 = UserFactory(nsid='11111111111@N01')
u2 = UserFactory(nsid='22222222222@N01')
FlickrAccountFactory(user=u1)
FlickrAccountFactory(user=u2)
PhotoFactory.create_batch(3, user=u1, is_private=False)
# These shouldn't be returned:
PhotoFactory(user=u1, is_private=True)
PhotoFactory(user=u2, is_private=False)
r = RecentObjects( (('flickr_photos', u1.nsid,),) )
objects = r.get_objects()
self.assertEqual(len(objects), 1)
for obj in objects:
self.assertEqual(obj['objects'][0].user, u1)
self.assertFalse(obj['objects'][0].is_private)
def test_years(self):
"Should include all intermediate years."
user = FlickrUserFactory(nsid='35034346050@N01')
PhotoFactory(user=user,
post_time=make_datetime('2014-01-01 12:00:00'))
PhotoFactory.create_batch(3,
user=user,
post_time=make_datetime('2016-01-01 12:00:00'))
PhotoFactory(user=user,
post_time=make_datetime('2018-01-01 12:00:00'))
result = FlickrGenerator(nsid='35034346050@N01').get_photos_per_year()
self.assertIn('data', result)
self.assertEqual(result['data'], [
{'label': '2014', 'value': 1},
{'label': '2015', 'value': 0},
{'label': '2016', 'value': 3},
{'label': '2017', 'value': 0},
{'label': '2018', 'value': 1},
])
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_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_user_detail_context_no_account(self):
"Sends correct data to templates for a User with no Account."
user = UserFactory()
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.assertIsNone(response.context['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):
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)
class TagViewTests(TestCase):
"""Have a bit more set up than the other tests, so may as well share it."""
def setUp(self):
"""
Creates two photos sharing three tags:
1 has 'fish' and 'carp' tags.
2 has 'fish' and 'cod' tags.
"""
self.carp_photo = PhotoFactory(title='Carp')
self.cod_photo = PhotoFactory(title='Cod')
fish_tag = TagFactory(slug='fish', name='Fish')
carp_tag = TagFactory(slug='carp', name='Carp')
cod_tag = TagFactory(slug='cod', name='Cod')
taggedphoto_1 = TaggedPhotoFactory(
content_object=self.carp_photo, tag=fish_tag)
taggedphoto_2 = TaggedPhotoFactory(
content_object=self.carp_photo, tag=carp_tag)
taggedphoto_3 = TaggedPhotoFactory(
content_object=self.cod_photo, tag=fish_tag)
taggedphoto_4 = TaggedPhotoFactory(
content_object=self.cod_photo, tag=cod_tag)
def createDogPhoto(self):
"Creates a photo tagged with 'dog' and 'mammal'."
self.dog_photo = PhotoFactory(title='Dog')
mammal_tag = TagFactory(slug='mammal')
dog_tag = TagFactory(slug='dog')
taggedphoto_5 = TaggedPhotoFactory(
content_object=self.dog_photo, tag=mammal_tag)
taggedphoto_6 = TaggedPhotoFactory(
content_object=self.dog_photo, tag=dog_tag)
# TAG LIST
def test_tag_list_templates(self):
"Uses the correct templates"
# Shouldn't need any photos to exist.
response = self.client.get(reverse('flickr:tag_list'))
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'flickr/tag_list.html')
self.assertTemplateUsed(response, 'flickr/base.html')
self.assertTemplateUsed(response, 'ditto/base.html')
def test_tag_list_context(self):
"Sends the correct data to templates"
response = self.client.get(reverse('flickr:tag_list'))
self.assertIn('tag_list', response.context)
self.assertIn('account_list', response.context)
self.assertEqual(len(response.context['tag_list']), 3)
def test_tag_list_privacy(self):
"Should only show tags from public Photos"
self.carp_photo.is_private = True
self.carp_photo.save()
response = self.client.get(reverse('flickr:tag_list'))
self.assertIn('tag_list', response.context)
self.assertEqual(len(response.context['tag_list']), 2)
# TAG DETAIL
def test_tag_detail_templates(self):
"Uses the correct templates"
response = self.client.get(reverse('flickr:tag_detail',
kwargs={'slug': 'fish'}))
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'flickr/tag_detail.html')
self.assertTemplateUsed(response, 'flickr/base.html')
self.assertTemplateUsed(response, 'ditto/base.html')
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_ordering_posted(self):
"By default, photos should be in reverse-post_time order."
dt = datetime_now()
self.carp_photo.post_time = dt - timedelta(days=2)
self.carp_photo.save()
self.cod_photo.post_time = dt - timedelta(days=1)
self.cod_photo.save()
response = self.client.get(reverse('flickr:tag_detail',
kwargs={'slug': 'fish'}))
pl = response.context['photo_list']
self.assertEqual(pl[0].pk, self.cod_photo.pk)
self.assertEqual(pl[1].pk, self.carp_photo.pk)
def test_tag_detail_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()
self.carp_photo.taken_time = dt - timedelta(days=2)
self.carp_photo.save()
self.cod_photo.taken_time = dt - timedelta(days=1)
self.cod_photo.save()
response = self.client.get(
reverse('flickr:tag_detail', kwargs={'slug': 'fish'}) + \
'?order=taken')
pl = response.context['photo_list']
self.assertEqual(pl[0].pk, self.cod_photo.pk)
self.assertEqual(pl[1].pk, self.carp_photo.pk)
def test_tag_detail_privacy(self):
"Does not display private Photos"
self.carp_photo.is_private = True
self.carp_photo.save()
response = self.client.get(reverse('flickr:tag_detail',
kwargs={'slug': 'carp'}))
self.assertEquals(response.status_code, 404)
def test_tag_detail_fails(self):
"Returns a 404 if a non-existent tag's page is requested"
response = self.client.get(reverse('flickr:tag_detail',
kwargs={'slug': 'bob'}))
self.assertEquals(response.status_code, 404)
## USER TAG DETAIL
def test_user_tag_detail_templates(self):
"Uses the correct templates"
response = self.client.get(reverse('flickr:user_tag_detail',
kwargs={'nsid': self.carp_photo.user.nsid, 'tag_slug': 'fish'}))
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'flickr/user_tag_detail.html')
self.assertTemplateUsed(response, 'flickr/base.html')
self.assertTemplateUsed(response, 'ditto/base.html')
def test_user_tag_detail_context(self):
"Sends the correct data to templates"
self.createDogPhoto()
# Ensure the cod, carp and dog photos are all owned by the same user.
# Only the carp and cod pics should show up on the user's 'fish' page.
self.cod_photo.user = self.carp_photo.user
self.cod_photo.save()
self.dog_photo.user = self.carp_photo.user
self.dog_photo.save()
response = self.client.get(reverse('flickr:user_tag_detail',
kwargs={'nsid': self.carp_photo.user.nsid, 'tag_slug': 'fish'}))
self.assertIn('tag', response.context)
self.assertEqual(response.context['tag'].name, '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(
[photo.pk for photo in response.context['photo_list']],
[1,2]
)
def test_user_tag_detail_ordering_posted(self):
"By default, photos should be in reverse-post_time order."
dt = datetime_now()
# Need two photos by same user to test ordering:
self.carp_photo.user = self.cod_photo.user
self.carp_photo.post_time = dt - timedelta(days=2)
self.carp_photo.save()
self.cod_photo.post_time = dt - timedelta(days=1)
self.cod_photo.save()
response = self.client.get(reverse('flickr:user_tag_detail',
kwargs={'nsid': self.carp_photo.user.nsid, 'tag_slug': 'fish'}))
pl = response.context['photo_list']
self.assertEqual(pl[0].pk, self.cod_photo.pk)
self.assertEqual(pl[1].pk, self.carp_photo.pk)
def test_user_tag_detail_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()
# Need two photos by same user to test ordering:
self.carp_photo.user = self.cod_photo.user
self.carp_photo.taken_time = dt - timedelta(days=2)
self.carp_photo.save()
self.cod_photo.taken_time = dt - timedelta(days=1)
self.cod_photo.save()
response = self.client.get(reverse('flickr:user_tag_detail',
kwargs={'nsid': self.carp_photo.user.nsid, 'tag_slug': 'fish'}) + \
'?order=taken')
pl = response.context['photo_list']
self.assertEqual(pl[0].pk, self.cod_photo.pk)
self.assertEqual(pl[1].pk, self.carp_photo.pk)
def test_user_tag_detail_privacy(self):
"Does not display private photos"
self.carp_photo.is_private = True
self.carp_photo.save()
response = self.client.get(reverse('flickr:user_tag_detail',
kwargs={'nsid': self.carp_photo.user.nsid, 'tag_slug': 'carp'}))
self.assertEquals(response.status_code, 404)
def test_user_tag_detail_fails_1(self):
"Returns a 404 if a non-existent user is requested"
response = self.client.get(reverse('flickr:user_tag_detail',
kwargs={'nsid': '99999999999@N99', 'tag_slug': 'fish'}))
self.assertEquals(response.status_code, 404)
def test_user_tag_detail_fails_2(self):
"Returns a 404 if a non-existent tag is requested"
response = self.client.get(reverse('flickr:user_tag_detail',
kwargs={'nsid': self.carp_photo.user.nsid, 'tag_slug': 'mammal'}))
self.assertEquals(response.status_code, 404)