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')