def test_public_manager(self):
"The public manager does NOT include private bookmarks"
public_bookmark_1 = BookmarkFactory(is_private=False)
private_bookmark = BookmarkFactory(is_private=True)
public_bookmark_2 = BookmarkFactory(is_private=False)
bookmarks = Bookmark.public_objects.all()
self.assertEqual(len(bookmarks), 2)
self.assertEqual(bookmarks[0].pk, public_bookmark_2.pk)
self.assertEqual(bookmarks[1].pk, public_bookmark_1.pk)
def test_url_constraint(self):
"""Ensures bookmarks have unique URLs within an Account"""
account = AccountFactory()
bookmark_1 = BookmarkFactory(account=account,
url='http://www.example.com')
bookmark_1.save()
with self.assertRaises(IntegrityError):
bookmark_2 = BookmarkFactory(account=account,
url='http://www.example.com')
def test_tag_list_privacy_bookmarks(self):
"Doesn't display tags from private bookmarks"
bookmark_1 = BookmarkFactory(is_private=True)
bookmark_1.tags.set('fish', 'carp')
bookmark_2 = BookmarkFactory(is_private=False)
bookmark_2.tags.set('fish', 'cod')
response = self.client.get(reverse('pinboard:tag_list'))
self.assertEqual(len(response.context['tag_list']), 2)
self.assertEqual(response.context['tag_list'][0].name, 'fish')
self.assertEqual(response.context['tag_list'][1].name, 'cod')
def test_tag_list_context(self):
"Sends the correct data to templates"
bookmark_1 = BookmarkFactory()
bookmark_1.tags.set('fish', 'carp')
bookmark_2 = BookmarkFactory()
bookmark_2.tags.set('fish', 'cod')
response = self.client.get(reverse('pinboard:tag_list'))
self.assertIn('account_list', response.context)
self.assertIn('tag_list', response.context)
self.assertEqual(len(response.context['tag_list']), 3)
def test_home_privacy(self):
"""Only public bookmarks should appear."""
public_bookmark_1 = BookmarkFactory(is_private=False)
private_bookmark = BookmarkFactory(is_private=True)
public_bookmark_2 = BookmarkFactory(is_private=False)
response = self.client.get(reverse('pinboard:home'))
bookmarks = response.context['bookmark_list']
self.assertEqual(len(bookmarks), 2)
self.assertEqual(bookmarks[0].pk, public_bookmark_2.pk)
self.assertEqual(bookmarks[1].pk, public_bookmark_1.pk)
def test_account_detail_privacy(self):
"It does not show private Bookmarks"
account = AccountFactory()
public_bookmark = BookmarkFactory(account=account, is_private=False)
private_bookmark = BookmarkFactory(account=account, is_private=True)
response = self.client.get(
reverse('pinboard:account_detail',
kwargs={'username': account.username}))
self.assertEqual(len(response.context['bookmark_list']), 1)
self.assertTrue(response.context['bookmark_list'][0].pk,
public_bookmark.pk)
def test_tags_privacy_bookmarks(self):
"Doesn't display tags from private bookmarks"
bookmark_1 = BookmarkFactory(is_private=True)
bookmark_1.tags.set('fish', 'carp')
bookmark_2 = BookmarkFactory(is_private=False)
bookmark_2.tags.set('fish', 'cod')
tags = ditto_pinboard.popular_bookmark_tags()
self.assertEqual(len(tags), 2)
self.assertEqual(tags[0].name, 'fish')
self.assertEqual(tags[0].num_times, 1)
self.assertEqual(tags[1].name, 'cod')
self.assertEqual(tags[1].num_times, 1)
def test_url_unconstrained(self):
"""URLs do not have to be unique for different Accounts' Bookmarks"""
account_1 = AccountFactory()
bookmark_1 = BookmarkFactory(account=account_1,
url='http://www.example.com')
bookmark_1.save()
account_2 = AccountFactory()
try:
bookmark_2 = BookmarkFactory(account=account_2,
url='http://www.example.com')
except IntegrityError:
self.fail(
"It looks like there's a Unique constraint on Bookmark.url, which there shouldn't be."
)
def test_ordering(self):
"Bookmarks are ordered correctly, most-recently-posted first"
account = AccountFactory(username='******')
post_time = datetime.datetime.strptime(
'2015-01-01 12:00:00',
"%Y-%m-%d %H:%M:%S").replace(tzinfo=pytz.utc)
bookmark_1 = BookmarkFactory(account=account, post_time=post_time)
bookmark_2 = BookmarkFactory(account=account,
post_time=(post_time +
datetime.timedelta(days=1)))
bookmarks = Bookmark.objects.all()
# Should be most recent first:
self.assertEqual(bookmarks[0].pk, bookmark_2.pk)
self.assertEqual(bookmarks[1].pk, bookmark_1.pk)
def test_tags(self):
"Contains the correct data"
bookmark_1 = BookmarkFactory()
bookmark_1.tags.set('fish', 'carp')
bookmark_2 = BookmarkFactory()
bookmark_2.tags.set('fish', 'cod')
tags = ditto_pinboard.popular_bookmark_tags()
self.assertEqual(len(tags), 3)
self.assertEqual(tags[0].name, 'fish')
self.assertEqual(tags[0].num_times, 2)
self.assertEqual(tags[1].name, 'carp')
self.assertEqual(tags[1].num_times, 1)
self.assertEqual(tags[2].name, 'cod')
self.assertEqual(tags[2].num_times, 1)
def setUp(self):
account_1 = AccountFactory(username='******')
account_2 = AccountFactory(username='******')
# Bookmarks in 2015 and 2016 for account_1:
BookmarkFactory.create_batch(3,
post_time=datetime_from_str('2015-01-01 12:00:00'),
account=account_1)
BookmarkFactory.create_batch(2,
post_time=datetime_from_str('2016-01-01 12:00:00'),
account=account_1)
# And one for account_2 in 2015:
BookmarkFactory(account=account_2,
post_time=datetime_from_str('2015-01-01 12:00:00'))
# And one private bookmark for account_1 in 2015:
BookmarkFactory(account=account_1, is_private=True,
post_time=datetime_from_str('2015-01-01 12:00:00'))
def test_no_update_bookmarks(self):
"""Ensure that if no values have changed, we don't update a bookmark.
"""
account = Account.objects.get(pk=1)
fetch_time = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
# Add a Bookmark into the DB before we fetch anything.
bookmark = BookmarkFactory(
account=account,
title='Fontello - icon fonts generator',
is_private=False,
to_read=False,
description='Create your own icon font using only the icons you need, select from Font Awesome and other free libraries.',
url='http://fontello.com/',
raw='{"extended": "Create your own icon font using only the icons you need, select from Font Awesome and other free libraries.", "hash": "df25b37a14ed631a0111a647e53fc24e", "description": "Fontello - icon fonts generator", "tags": "fonts icons webdevelopment webdesign", "href": "http://fontello.com/", "meta": "20e8a3c17e9424c7fb6121d0c6961861", "time": "2015-06-18T09:48:31Z", "shared": "yes", "toread": "no"}',
fetch_time=fetch_time)
bookmarks_from_json = self.get_bookmarks_from_json()
bookmarks_data = bookmarks_from_json['bookmarks']
BookmarksFetcher()._save_bookmarks(
account=account,
bookmarks_data=bookmarks_data,
fetch_time=fetch_time)
self.assertEqual(Bookmark.objects.all().count(), 2)
bookmarks = Bookmark.objects.all()
# Nothing has changed, and so the fetch_time should be the original:
self.assertEqual(bookmarks[0].fetch_time, fetch_time)
def test_get_absolute_url(self):
"Has the correct URL on this site"
account = AccountFactory(username='******')
bookmark = BookmarkFactory(account=account,
url='http://www.example.com')
self.assertEqual(bookmark.get_absolute_url(),
'/pinboard/billy/847310eb455f/')
def test_tag_detail_privacy(self):
"Does not display private bookmarks"
bookmark = BookmarkFactory(is_private=True)
bookmark.tags.set('fish')
response = self.client.get(
reverse('pinboard:tag_detail', kwargs={'slug': 'fish'}))
self.assertEquals(response.status_code, 404)
def test_tags_limit_default(self):
"It should return 10 tags by default"
bookmark = BookmarkFactory()
bookmark.tags.set('1', '2', '3', '4', '5', '6', '7', '8', '9', '10',
'11')
tags = ditto_pinboard.popular_bookmark_tags()
self.assertEqual(len(tags), 10)
def test_empty_years(self):
"It should include years for which there are no bookmarks."
# Add a photo in 2018, leaving a gap for 2017:
BookmarkFactory(post_time=datetime_from_str('2018-01-01 12:00:00'))
bookmarks = ditto_pinboard.annual_bookmark_counts()
self.assertEqual(len(bookmarks), 4)
self.assertEqual(bookmarks[2]['year'], 2017)
self.assertEqual(bookmarks[2]['count'], 0)
def test_case_insensitive_tags(self):
"Creating tags named 'dog' and 'DOG' should not create different slugs."
bookmark = BookmarkFactory()
bookmark.tags.set('dog', 'cat', 'DOG')
self.assertEqual(sorted([tag.slug for tag in bookmark.tags.all()]), [
'cat',
'dog',
])
def test_tags_private(self):
"Doesn't fetch private tags"
bookmark = BookmarkFactory()
bookmark.tags.set('ispublic', '.isprivate', 'alsopublic')
bookmark_reloaded = Bookmark.objects.get(pk=bookmark.pk)
self.assertEqual(len(bookmark_reloaded.tags.all()), 2)
self.assertEqual(bookmark_reloaded.tags.names().first(), 'alsopublic')
self.assertEqual(bookmark_reloaded.tags.all()[0].name, 'alsopublic')
self.assertEqual(bookmark_reloaded.tags.all()[1].name, 'ispublic')
def test_tag_detail_templates(self):
"Uses the correct templates"
bookmark = BookmarkFactory()
bookmark.tags.set('fish')
response = self.client.get(
reverse('pinboard:tag_detail', kwargs={'slug': 'fish'}))
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'pinboard/tag_detail.html')
self.assertTemplateUsed(response, 'pinboard/base.html')
self.assertTemplateUsed(response, 'ditto/base.html')
def test_bookmark_detail_privacy(self):
"Does not display private bookmarks"
bookmark = BookmarkFactory(is_private=True)
response = self.client.get(
reverse('pinboard:bookmark_detail',
kwargs={
'username': bookmark.account.username,
'hash': bookmark.url_hash
}))
self.assertEquals(response.status_code, 404)
def test_tags(self):
"Can save and recall tags"
bookmark = BookmarkFactory()
bookmark.tags.set('banana', 'cherry', 'apple')
bookmark_reloaded = Bookmark.objects.get(pk=bookmark.pk)
self.assertEqual(len(bookmark_reloaded.tags.all()), 3)
self.assertIsInstance(bookmark_reloaded.tags.first(), BookmarkTag)
self.assertEqual(bookmark_reloaded.tags.names().first(), 'apple')
self.assertEqual(bookmark_reloaded.tags.all()[0].name, 'apple')
self.assertEqual(bookmark_reloaded.tags.all()[2].name, 'cherry')
def test_bookmark_detail_fails(self):
"Returns a 404 if a non-existent bookmark's page is requested"
bookmark = BookmarkFactory()
response = self.client.get(
reverse('pinboard:bookmark_detail',
kwargs={
'username': bookmark.account.username,
'hash': '1234567890ab'
}))
self.assertEquals(response.status_code, 404)
def test_bookmark_detail_context(self):
"Sends the correct data to templates"
bookmark = BookmarkFactory()
response = self.client.get(
reverse('pinboard:bookmark_detail',
kwargs={
'username': bookmark.account.username,
'hash': bookmark.url_hash
}))
self.assertIn('bookmark', response.context)
self.assertEqual(bookmark.pk, response.context['bookmark'].pk)
def test_tag_list_privacy_tags(self):
"Doesn't display private .tags"
bookmark = BookmarkFactory()
bookmark.tags.set('ispublic', '.notpublic', 'alsopublic')
response = self.client.get(reverse('pinboard:tag_list'))
self.assertEqual(len(response.context['tag_list']), 2)
# Tags on this page are ordered by popularity, so can't be sure
# which is 'alsopublic' and which is 'ispublic':
tag_names = [tag.name for tag in response.context['tag_list']]
self.assertIn('alsopublic', tag_names)
self.assertIn('ispublic', tag_names)
def test_tags_privacy_tags(self):
"Doesn't display private .tags"
bookmark = BookmarkFactory()
bookmark.tags.set('ispublic', '.notpublic', 'alsopublic')
tags = ditto_pinboard.popular_bookmark_tags()
self.assertEqual(len(tags), 2)
# Tags are ordered by popularity, so can't be sure
# which is 'alsopublic' and which is 'ispublic':
tag_names = [tag.name for tag in tags]
self.assertIn('alsopublic', tag_names)
self.assertIn('ispublic', tag_names)
def test_bookmark_detail_templates(self):
"Uses the correct templates"
bookmark = BookmarkFactory()
response = self.client.get(
reverse('pinboard:bookmark_detail',
kwargs={
'username': bookmark.account.username,
'hash': bookmark.url_hash
}))
self.assertEquals(response.status_code, 200)
self.assertTemplateUsed(response, 'pinboard/bookmark_detail.html')
def test_account_tag_detail_fails_1(self):
"Returns a 404 if a non-existent account is requested"
bookmark = BookmarkFactory()
bookmark.tags.set('fish')
response = self.client.get(
reverse('pinboard:account_tag_detail',
kwargs={
'username': '******',
'tag_slug': 'fish'
}))
self.assertEquals(response.status_code, 404)
def test_tag_detail_context(self):
"Sends the correct data to the templates"
bookmark_1 = BookmarkFactory(title='Carp')
bookmark_1.tags.set('Fish', 'carp')
bookmark_2 = BookmarkFactory(title='Cod')
bookmark_2.tags.set('Fish', 'cod')
bookmark_3 = BookmarkFactory(title='Dog')
bookmark_3.tags.set('mammals', 'dog')
response = self.client.get(
reverse('pinboard:tag_detail', kwargs={'slug': 'fish'}))
self.assertIn('account_list', response.context)
self.assertEqual(
[account.pk for account in response.context['account_list']],
[1, 2, 3])
self.assertIn('tag', response.context)
self.assertEqual(response.context['tag'].name, 'Fish')
self.assertIn('bookmark_list', response.context)
self.assertEqual(len(response.context['bookmark_list']), 2)
self.assertEqual(response.context['bookmark_list'][0].title, 'Cod')
self.assertEqual(response.context['bookmark_list'][1].title, 'Carp')
def setUp(self):
dt = datetime.datetime.strptime(
'2016-04-08 12:00:00',
'%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.utc)
account = AccountFactory()
self.bookmark_1 = BookmarkFactory(account=account, post_time=dt)
self.private_bookmark = BookmarkFactory(account=account,
is_private=True,
post_time=dt +
datetime.timedelta(days=1))
# Bookmark by a different user:
account_2 = AccountFactory()
self.other_bookmark = BookmarkFactory(account=account_2,
post_time=dt +
datetime.timedelta(days=2))
self.bookmark_2 = BookmarkFactory(account=account,
post_time=dt +
datetime.timedelta(days=3))
def test_account_tag_detail_fails_2(self):
"Returns a 404 if a non-existent tag is requested"
account = AccountFactory()
bookmark = BookmarkFactory(account=account)
bookmark.tags.set('fish')
response = self.client.get(
reverse('pinboard:account_tag_detail',
kwargs={
'username': account.username,
'tag_slug': 'mammals'
}))
self.assertEquals(response.status_code, 404)