def test_endpoint_paging(self):
'''Page out more than 20 feeds.'''
# Test data
for i in xrange(0, 50):
Feed.create_and_subscribe(
'feed {0}'.format(i),
'http://www.example.com/rss{0}'.format(i),
None, self.user)
# Actual test
result = self.api_client.get('/api/0.9.5/feed/')
self.assertEqual(200, result.status_code)
content = json.loads(result.content)
self.assertEqual(content.keys(), ['meta', 'objects'])
self.assertEqual(
content['meta'].keys(),
['previous', 'total_count', 'offset', 'limit', 'next'])
self.assertEqual(content['meta']['previous'], None)
self.assertEqual(content['meta']['total_count'], 50)
self.assertEqual(content['meta']['offset'], 0)
self.assertEqual(content['meta']['limit'], 20)
self.assertEqual(
content['meta']['next'].split('?')[1],
'limit=20&offset=20')
self.assertEqual(len(content['objects']), 20)
def test_endpoint_only_owned(self):
'''Don't return feeds where UserFeed.user is not the user.'''
# Test data
feed = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss', None, self.user)
mike = User.objects.create_user(
'mike', '*****@*****.**', password='******')
mike.save()
feed = Feed.create_and_subscribe(
'Gothamist', 'http://feeds.gothamistllc.com/gothamist05', None, mike)
# Actual test
result = self.api_client.get('/api/0.9.5/feed/')
self.assertEqual(200, result.status_code)
content = json.loads(result.content)
self.assertEqual(content.keys(), ['meta', 'objects'])
self.assertEqual(
content['meta'].keys(),
['previous', 'total_count', 'offset', 'limit', 'next'])
self.assertEqual(content['meta']['previous'], None)
self.assertEqual(content['meta']['total_count'], 1)
self.assertEqual(content['meta']['offset'], 0)
self.assertEqual(content['meta']['limit'], 20)
self.assertEqual(content['meta']['next'], None)
def _import_subscriptions(self):
subscriptions = None
for f in self.z.namelist():
if 'subscriptions.xml' in f:
subscriptions = opml.from_string(self.z.open(f).read())
break
if subscriptions is None:
return False
for sub in subscriptions:
if hasattr(sub, 'type'):
title = sub.title
link = sub.xmlUrl
site = sub.htmlUrl
Feed.create_and_subscribe(title, link, site, self.user)
else:
# In this case, it's a 'group' of feeds.
folder = sub
for sub in folder:
title = sub.title
link = sub.xmlUrl
site = sub.htmlUrl
feed = Feed.create_and_subscribe(title, link, site, self.user)
userfeed = feed.userfeed(self.user)
userfeed.tags.add(folder.title)
return True
def test_unauthorized(self):
feed = Feed()
feed.link = 'http://www.paulhummer.org/rss'
feed.save()
uri = '/api/0.9/feed/{0}'.format(feed.pk)
response = self.client.get(uri, follow=True)
self.assertEqual(response.status_code, 404)
def test_feeds_but_no_subscriptions(self):
feed = Feed()
feed.link = 'http://www.paulhummer.org/rss'
feed.save()
response = self.client.get('/api/0.9/feed/')
content = json.loads(response.content)
objects = content['objects']
self.assertEqual(len(objects), 0)
def test_resource_read(self):
feed = Feed()
feed.link = 'http://www.paulhummer.org/rss'
feed.save()
feed.update()
feed.add_subscriber(self.user)
response = self.client.get('/api/0.9/item/')
self.assertEqual(response.status_code, 200)
content = json.loads(response.content)
objects = content['objects']
resource = objects[0]
response = self.client.get(resource['resource_uri'])
self.assertEqual(response.status_code, 200)
content = json.loads(response.content)
resource_id = resource['resource_uri'].split('/')[-2]
item = FeedItem.objects.get(pk=resource_id)
useritem = UserFeedItem.objects.get(user=self.user, item=item)
self.assertEqual(resource['read'], False)
useritem.read = True
useritem.save()
response = self.client.get(resource['resource_uri'])
resource = json.loads(response.content)
self.assertEqual(resource['read'], True)
def test_resource_put_read(self):
feed = Feed()
feed.link = 'http://www.paulhummer.org/rss'
feed.save()
feed.update()
feed.add_subscriber(self.user)
response = self.client.get('/api/0.9/item/')
self.assertEqual(response.status_code, 200)
content = json.loads(response.content)
objects = content['objects']
resource = objects[0]
response = self.client.get(resource['resource_uri'])
self.assertEqual(response.status_code, 200)
resource = json.loads(response.content)
self.assertEqual(resource['read'], False)
resource['read'] = True
self.client.put(
resource['resource_uri'],
data=json.dumps(resource),
content_type='application/json')
response = self.client.get(resource['resource_uri'])
resource = json.loads(response.content)
self.assertEqual(resource['read'], True)
def test_dates(self):
links = [
"http://theworstthingever.com/index.rdf",
"http://news.ycombinator.com/rss",
"http://aw.lackof.org/~awilliam/blog/index.rss",
"http://adeem.me/blog/feed/rss/",
"http://lusars.net/~mhunter/rss.xml",
"http://feeds.feedburner.com/Manbabies",
"http://www.365portraits.com/rss.php",
"http://iphonedevelopmentbits.com/feed/rss",
"http://blog.myspace.com/blog/rss.cfm?friendID=4470742",
]
for link in links:
feed = Feed()
feed.link = link
feed.save()
feed.update()
first_update = feed.items.count()
# Pause a few seconds, so when we fetch again, utcnow() in the
# model will be a different time (and therefore potentially a
# different GUID)
time.sleep(3)
feed.update()
second_update = feed.items.count()
# Ensure that fetching feeds with missing or malformed dates
# do not result in different GUIDs (they should resolve to
# the same GUID).
self.assertEqual(first_update, second_update)
def test_run(self):
with open(SECURE_FILE) as f:
secure = f.read()
owner = User()
owner.email = 'Alex'
owner.save()
other_owner = User()
other_owner.email = 'Mike'
other_owner.save()
other_feed = Feed()
other_feed.save()
other_owner.subscribe(other_feed)
task = tasks.SyncFromReaderAPITask()
result = task.delay(owner, 10, '*****@*****.**', secure)
self.assertTrue(result.successful())
feeds = Feed.objects.all()
# Tricky. We are subscribed to 122 feeds
# We create another feed above, to get to 123
# But 3 feeds in the import were "shared-with-you" so the total
# number of feeds should be 126
self.assertEqual(feeds.count(), 126)
total_feeds = Feed.objects.all().count()
owner = User.objects.get(pk=owner.pk)
# Verify that we do not get subscribed to feeds when items are
# 'shared-with-you'.
self.assertEqual(owner.feeds.count(), 122)
# Ensure create_raw() won't create a duplicate feed
title = u'A Softer World'
link = u'http://www.rsspect.com/rss/asw.xml'
site = u'http://www.asofterworld.com'
feed = Feed.objects.get(link=link)
duplicate = Feed.create_raw(title, link, site)
duplicate.add_subscriber(owner)
self.assertEqual(feed.pk, duplicate.pk)
# Testing that subscribing a second time doesn't blow up.
duplicate2 = Feed.create_and_subscribe(title, link, site, owner)
self.assertEqual(feed.pk, duplicate2.pk)
tagged = UserFeedItem.objects.filter(tags__name__in=['shared-with-you'])
self.assertEqual(len(tagged), 10)
def test_autodiscovery(self):
# Test discovery
url = "http://boingboing.net"
feed = Feed.autodiscover(url)
self.assertEqual(feed, "http://boingboing.net/atom.xml")
# Ensure passing an RSS link returns itself
url = "http://www.rsspect.com/rss/asw.xml"
feed = Feed.autodiscover(url)
self.assertEqual(feed, url)
# Bogus url
url = "http://"
feed = Feed.autodiscover(url)
self.assertEqual(feed, None)
def test_lookup_by_unread_and_feed(self):
'''Only return the unread items by feed.'''
# Test data
feed = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss', None, self.user)
item = FeedItem()
item.feed = feed
item.title = 'Feed title'
item.link = 'http://www.paulhummer.org/rss/1'
item.guid = 'http://www.paulhummer.org/rss/1'
item.published = datetime.now()
item.save()
item2 = FeedItem()
item2.feed = feed
item2.title = 'Feed title 2'
item2.link = 'http://www.paulhummer.org/rss/2'
item2.guid = 'http://www.paulhummer.org/rss/2'
item2.published = datetime.now()
item2.save()
userfeed = UserFeed.objects.get(user=self.user, feed=feed)
userfeeditem = UserFeedItem.objects.get(
user=self.user, feed=feed, item=item)
userfeeditem.read = True
userfeeditem.save()
mike = User.objects.create_user(
'mike', '*****@*****.**', password='******')
mike.save()
feed2 = Feed.create_and_subscribe(
'Gothamist', 'http://feeds.gothamistllc.com/gothamist05-', None, mike)
item4 = FeedItem()
item4.feed = feed2
item4.title = 'Feed title'
item4.link = 'http://www.gothamist.com/rss/1'
item4.guid = 'http://www.gothamist.com/rss/1'
item4.published = datetime.now()
item4.save()
# Actual test
result = self.api_client.get(
'/api/0.9.5/item/?read=False&feed={0}'.format(userfeed.pk))
self.assertEqual(200, result.status_code)
content = json.loads(result.content)
self.assertEqual(len(content['objects']), 1)
def test_malformed(self):
"""Test nasty feeds that we've discovered in the wild"""
owner = User()
owner.email = "Bob"
owner.save()
# Really long titles.
title = u"minimal linux"
link = u"http://minimallinux.com/rss"
site = u"http://minimallinux.com/"
feed = Feed.create_and_subscribe(title, link, site, owner)
# This feed is dead, so we don't expect any items downloaded.
userfeeditems = FeedItem.objects.for_user(owner)
self.assertEqual(userfeeditems.count(), 0)
# Discovered while trying to import from google reader.
# >>> len(e.title)
# 857
item = FeedItem()
item.feed = feed
item.title = u"This isn't a question but more of a submission for your \"enough\" poll-type thing.<br>\r\n<br>\r\nI would go with Arch as my main distro. It\u2019s the simplest and easiest to setup of any distro I\u2019ve used.<br>\r\n<br>\r\nMy window manager of choice would be dwm. Amazingly simple and very customizable.<br>\r\n<br>\r\nI would use vim for any text editing I would need to do (which mostly involves programming)<br>\r\n<br>\r\nI would be able to get away with using feh as my image viewer, since I never really need to do any image editing.<br>\r\n<br>\r\nChromium, of course.<br>\r\n<br>\r\nI would use dmenu as my app launcher. Another suckless creation, very simple and very fast.<br>\r\n<br>\r\nDropbox for file syncing.<br>\r\n<br>\r\nPidgin (haven't looked that much for something simpler) for AIM.<br>\r\n<br>\r\nI would also need a few programming related things such as ruby, gcc, make, etc."
item.link = u"http://minimallinux.com/post/7031884799"
item.description = u"<p>Nice\u2014good stuff here. I really dig dmenu.</p>"
item.published = datetime.utcfromtimestamp(1309319839)
item.atom_id = ""
item.reader_guid = u"tag:google.com,2005:reader/item/022fe5bb1abdb67a"
item.guid = item.calculate_guid()
item.save()
userfeeditems = FeedItem.objects.for_user(owner)
self.assertEqual(userfeeditems.count(), 1)
def test_run(self):
feed = Feed()
feed.link = 'http://paulhummer.org/rss'
last_fetched = datetime.now() - timedelta(minutes=31)
feed.last_fetched = last_fetched
feed.save()
task = tasks.UpdateFeedTask()
result = task.delay()
self.assertTrue(result.successful())
# Re-fetch the feed
feed = Feed.objects.get(link='http://paulhummer.org/rss')
self.assertNotEqual(feed.last_fetched, last_fetched)
self.assertEqual(feed.items.count(), 20)
def test_endpoint_by_id(self):
'''Get a specific feed item.'''
feed = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss', None, self.user)
item = FeedItem()
item.feed = feed
item.title = 'Feed title'
item.link = 'http://www.paulhummer.org/rss/1'
item.guid = 'http://www.paulhummer.org/rss/1'
item.published = datetime.now()
item.save()
userfeeditem = UserFeedItem.objects.get(user=self.user, item=item)
userfeeditem.tags.add('hipster', 'douche')
userfeeditem.save()
result = self.api_client.get('/api/0.9.5/item/')
content = json.loads(result.content)
result = self.api_client.get(content['objects'][0]['resource_uri'])
self.assertEqual(200, result.status_code)
content = json.loads(result.content)
self.assertEqual(
sorted(content.keys()),
['description', 'feed', 'feed_id', 'feed_tags', 'feed_title',
'id', 'link', 'published', 'read', 'resource_uri', 'starred',
'tags', 'title'])
self.assertEqual(content['description'], item.description)
self.assertEqual(content['link'], item.link)
self.assertEqual(
dateutil.parser.parse(content['published']),
item.published)
self.assertEqual(content['title'], item.title)
self.assertEqual(content['feed'], '/api/0.9.5/feed/1/')
self.assertEqual(content['tags'], ['hipster', 'douche'])
def test_endpoint_paging(self):
'''Page out more than 20 items.'''
# Test data
feed = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss', None, self.user)
for i in xrange(0, 50):
item = FeedItem()
item.feed = feed
item.title = 'Feed title {0}'.format(i)
item.link = 'http://www.paulhummer.org/rss/{0}'.format(i)
item.guid = 'http://www.paulhummer.org/rss/{0}'.format(i)
item.published = datetime.now()
item.save()
# Actual test
result = self.api_client.get('/api/0.9.5/item/')
self.assertEqual(200, result.status_code)
content = json.loads(result.content)
self.assertEqual(content.keys(), ['meta', 'objects'])
self.assertEqual(
content['meta'].keys(),
['previous', 'total_count', 'offset', 'limit', 'next'])
self.assertEqual(content['meta']['previous'], None)
self.assertEqual(content['meta']['total_count'], 50)
self.assertEqual(content['meta']['offset'], 0)
self.assertEqual(content['meta']['limit'], 20)
self.assertEqual(
content['meta']['next'].split('?')[1],
'limit=20&offset=20')
self.assertEqual(len(content['objects']), 20)
def test_endpoint_single_item(self):
'''The root feed endpoint returns a list of items.'''
# Test data
feed = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss', None, self.user)
item = FeedItem()
item.feed = feed
item.title = 'Feed title'
item.link = 'http://www.paulhummer.org/rss/1'
item.guid = 'http://www.paulhummer.org/rss/1'
item.published = datetime.now()
item.save()
# Actual test
result = self.api_client.get('/api/0.9.5/item/')
self.assertEqual(200, result.status_code)
content = json.loads(result.content)
self.assertEqual(content.keys(), ['meta', 'objects'])
self.assertEqual(
content['meta'].keys(),
['previous', 'total_count', 'offset', 'limit', 'next'])
self.assertEqual(content['meta']['previous'], None)
self.assertEqual(content['meta']['total_count'], 1)
self.assertEqual(content['meta']['offset'], 0)
self.assertEqual(content['meta']['limit'], 20)
self.assertEqual(content['meta']['next'], None)
def test_filter_by_tag(self):
'''Only return feeds by a given tag.'''
feed = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss', None, self.user)
userfeed = UserFeed.objects.get(user=self.user, feed=feed)
userfeed.tags.add('hipster', 'douchery')
userfeed.save()
feed2 = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss1', None, self.user)
userfeed2 = UserFeed.objects.get(user=self.user, feed=feed2)
userfeed2.tags.add('test', 'tags')
userfeed2.save()
result = self.api_client.get('/api/0.9.5/feed/?tags=hipster')
content = json.loads(result.content)
self.assertEqual(content['meta']['total_count'], 1)
def test_userfeed_tags(self):
bob = User.objects.create_user("bob", "*****@*****.**", password="******")
bob.save()
bob_feed = Feed.create_and_subscribe("Paul Hummer", "http://www.paulhummer.org/rss", None, bob)
bob_userfeed = UserFeed.objects.get(user=bob, feed=bob_feed)
bob_userfeed.tags.add("linux", "nerd")
bob_userfeed.save()
mark = User.objects.create_user("mark", "*****@*****.**", password="******")
mark.save()
mark_feed = Feed.create_and_subscribe("Paul Hummer", "http://www.paulhummer.org/rss1", None, mark)
mark_userfeed = UserFeed.objects.get(user=mark, feed=mark_feed)
mark_userfeed.tags.add("linux")
mark_userfeed.save()
tags = UserFeed.userfeed_tags(bob)
self.assertEqual(tags.count(), 2)
self.assertEqual([tag.name for tag in tags.all()], ["linux", "nerd"])
def test_duplicates(self):
"""Ensure that we can't create duplicate feeds using create_and_subscribe()"""
user = User()
user.email = "Bob"
user.save()
feed = Feed()
feed.title = "BoingBoing"
feed.link = "http://boingboing.net/atom.xml"
feed.site = "http://boingboing.net"
f = Feed.create_and_subscribe(feed.title, feed.link, feed.site, user)
feed2 = Feed()
feed2.title = "BoingBoing"
feed2.link = "http://boingboing.net/atom.xml"
feed2.site = "http://boingboing.net"
# XXX: TODO: we need to add/test duplicate checks save() too :(
f2 = Feed.create_and_subscribe(feed2.title, feed2.link, feed2.site, user)
self.assertEqual(f.pk, f2.pk)
def test_lookup_by_feed_id(self):
'''Filter items by feed.id.'''
# Test data
feed = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss', None, self.user)
item = FeedItem()
item.feed = feed
item.title = 'Feed title'
item.link = 'http://www.paulhummer.org/rss/1'
item.guid = 'http://www.paulhummer.org/rss/1'
item.published = datetime.now()
item.save()
item = FeedItem()
item.feed = feed
item.title = 'Feed title 2'
item.link = 'http://www.paulhummer.org/rss/2'
item.guid = 'http://www.paulhummer.org/rss/2'
item.published = datetime.now()
item.save()
feed2 = Feed.create_and_subscribe(
'Gothamist', 'http://feeds.gothamistllc.com/gothamist05', None,
self.user)
item2 = FeedItem()
item2.feed = feed2
item2.title = 'Feed title'
item2.link = 'http://www.gothamist.com/rss/1'
item2.guid = 'http://www.gothamist.com/rss/1'
item2.published = datetime.now()
item2.save()
userfeed = UserFeed.objects.get(user=self.user, feed=feed)
# Actual test
result = self.api_client.get(
'/api/0.9.5/item/?feed={0}'.format(userfeed.pk))
self.assertEqual(200, result.status_code)
content = json.loads(result.content)
self.assertEqual(len(content['objects']), 2)
def test_lookup_by_feed_tag(self):
'''Only return the unread items.'''
# Test data
feed = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss', None, self.user)
item = FeedItem()
item.feed = feed
item.title = 'Feed title'
item.link = 'http://www.paulhummer.org/rss/1'
item.guid = 'http://www.paulhummer.org/rss/1'
item.published = datetime.now()
item.save()
item2 = FeedItem()
item2.feed = feed
item2.title = 'Feed title 2'
item2.link = 'http://www.paulhummer.org/rss/2'
item2.guid = 'http://www.paulhummer.org/rss/2'
item2.published = datetime.now()
item2.save()
userfeed2 = UserFeed.objects.get(user=self.user, feed=feed)
userfeed2.tags.add('hipster')
userfeed2.save()
feed2 = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss1', None, self.user)
item3 = FeedItem()
item3.feed = feed2
item3.title = 'Feed title 3'
item3.link = 'http://www.paulhummer.org/rss/3'
item3.guid = 'http://www.paulhummer.org/rss/3'
item3.published = datetime.now()
item3.save()
# Actual test
result = self.api_client.get(
'/api/0.9.5/item/?feed_tags=hipster')
self.assertEqual(200, result.status_code)
content = json.loads(result.content)
self.assertEqual(len(content['objects']), 2)
def test_duplicates(self):
user = User()
user.email = 'Bob'
user.save()
tmp = Feed()
tmp.title = 'Marginal Revolution'
tmp.link = 'http://feeds.feedburner.com/marginalrevolution/feed'
tmp.site = 'http://marginalrevolution.com/'
last_fetched = datetime.now() - timedelta(minutes=31)
tmp.last_fetched = last_fetched
# Fetch #1
feed = Feed.create_and_subscribe(tmp.title, tmp.link, tmp.site, user)
# Fetch #2
task1 = tasks.UpdateFeedTask()
result1 = task1.delay()
# Force fetch #3
last_fetched = datetime.now() - timedelta(minutes=31)
feed.last_fetched = last_fetched
feed.save()
task2 = tasks.UpdateFeedTask()
result2 = task2.delay()
self.assertEqual(feed.feeditems.count(), 15)
def test_unsubscribe(self):
feed = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss', None, self.user)
userfeed = UserFeed.objects.get(user=self.user, feed=feed)
response = self.api_client.delete(
'/api/0.9.5/feed/{0}/'.format(userfeed.pk))
self.assertEqual(response.status_code, 204)
#Ensure the feed is now deleted.
response = self.api_client.get('/api/0.9/feed/')
content = json.loads(response.content)
self.assertEqual(len(content['objects']), 0)
def test_run(self):
owner = User()
owner.email = 'Bob'
owner.save()
other_owner = User()
other_owner.email = 'Mike'
other_owner.save()
other_feed = Feed()
other_feed.save()
other_owner.subscribe(other_feed)
task = tasks.EatTakeoutTask()
result = task.delay(
owner,
os.path.join(TESTDATA_DIR, '*****@*****.**'))
self.assertTrue(result.successful())
total_feeds = Feed.objects.all().count()
owner = User.objects.get(pk=owner.pk)
self.assertEqual(total_feeds, 146)
self.assertEqual(owner.feeds.count(), 122)
starred = UserFeedItem.objects.filter(starred=True)
self.assertEqual(len(starred), 9)
shared_with_me = UserFeedItem.objects.filter(tags__name__in=['shared-with-you'])
self.assertEqual(len(shared_with_me), 31)
shared = UserFeedItem.objects.filter(tags__name__in=['shared'])
self.assertEqual(len(shared), 1)
# See how all the above should add up!
imported = UserFeedItem.objects.filter(tags__name__in=['imported'])
self.assertEqual(len(imported), 41)
def test_tagging(self):
user = User()
user.email = "Bob"
user.save()
feed = Feed()
feed.title = "BoingBoing"
feed.link = "http://boingboing.net"
feed.save()
feed.add_subscriber(user)
item = FeedItem()
item.title = "Octopus v. Platypus"
item.description = "A fight to the death."
item.link = item.guid = "http://www.example.com/rss/post"
item.published = datetime.now()
item.feed = feed
item.save()
item2 = FeedItem()
item2.title = "Cute bunny rabbit video"
item2.description = "They die at the end."
item2.link = item.guid = "http://www.example.com/rss/post"
item2.published = datetime.now()
item2.feed = feed
item2.save()
userfeeditem = UserFeedItem.objects.get(user=user, item=item)
userfeeditem.tags.add("cute", "platypus")
userfeeditem2 = UserFeedItem.objects.get(user=user, item=item2)
userfeeditem2.tags.add("bunny", "cute")
self.assertIn("cute", [tag.name for tag in userfeeditem.tags.all()])
self.assertIn("platypus", [tag.name for tag in userfeeditem.tags.all()])
self.assertNotIn("bunny", [tag.name for tag in userfeeditem.tags.all()])
tagged = UserFeedItem.objects.filter(tags__name__in=["cute"])
self.assertEquals(len(tagged), 2)
userfeeditem.tags.set("test")
self.assertEquals(len(userfeeditem.tags.all()), 1)
self.assertNotIn("cute", [tag.name for tag in userfeeditem.tags.all()])
# API claims we can do this safely without raising an exception
userfeeditem.tags.remove("cute")
userfeeditem.tags.clear()
self.assertEquals(len(userfeeditem.tags.all()), 0)
def test_user_subscribe(self):
'''Test the syntactic sugar monkeypatch for User.subscribe.'''
user = User()
user.email = 'Bob'
user.save()
feed = Feed()
feed.title = 'BoingBoing'
feed.link = 'http://boingboing.net'
feed.save()
unused = Feed()
unused.title = 'xkcd'
unused.save()
item = FeedItem()
item.title = 'Octopus v. Platypus'
item.description = 'A fight to the death.'
item.link = item.guid = 'http://www.example.com/rss/post'
item.published = datetime.now()
item.feed = feed
item.save()
item2 = FeedItem()
item2.title = 'Cute bunny rabbit video'
item2.description = 'They die at the end.'
item2.link = item.guid = 'http://www.example.com/rss/post'
item2.published = datetime.now()
item2.feed = feed
item2.save()
user.subscribe(feed)
self.assertEqual(user.feeds.count(), 1)
self.assertEqual(user.feeditems.count(), 2)
self.assertEqual(user.feeds[0].title, feed.title)
# Testing we are using order_by() in User.feeditems() monkeypatch
self.assertEqual(user.feeditems[0].title, item.title)
def test_sort_published(self):
'''We can sort by 'published'.'''
# Test data
feed = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss', None, self.user)
item = FeedItem()
item.feed = feed
item.title = 'Feed 1'
item.link = 'http://www.paulhummer.org/rss/1'
item.guid = 'http://www.paulhummer.org/rss/1'
item.published = datetime.now()
item.save()
item = FeedItem()
item.feed = feed
item.title = 'Feed 2'
item.link = 'http://www.paulhummer.org/rss/2'
item.guid = 'http://www.paulhummer.org/rss/2'
item.published = datetime.now() - timedelta(days=-1)
item.save()
item = FeedItem()
item.feed = feed
item.title = 'Feed 3'
item.link = 'http://www.paulhummer.org/rss/3'
item.guid = 'http://www.paulhummer.org/rss/3'
item.published = datetime.now() - timedelta(days=-2)
item.save()
# Actual test
result = self.api_client.get('/api/0.9.5/item/?order_by=-published')
self.assertEqual(result.status_code, 200)
content = json.loads(result.content)
self.assertEqual(
[item['title'] for item in content['objects']],
['Feed 3', 'Feed 2', 'Feed 1'])
result = self.api_client.get('/api/0.9.5/item/?order_by=published')
self.assertEqual(result.status_code, 200)
content = json.loads(result.content)
self.assertEqual(
[item['title'] for item in content['objects']],
['Feed 1', 'Feed 2', 'Feed 3'])
def test_endpoint_single_item(self):
'''The root feed endpoint returns a list of feeds.'''
feed = Feed.create_and_subscribe(
'Paul Hummer', 'http://www.paulhummer.org/rss', None, self.user)
result = self.api_client.get('/api/0.9.5/feed/')
self.assertEqual(200, result.status_code)
content = json.loads(result.content)
self.assertEqual(content.keys(), ['meta', 'objects'])
self.assertEqual(
content['meta'].keys(),
['previous', 'total_count', 'offset', 'limit', 'next'])
self.assertEqual(content['meta']['previous'], None)
self.assertEqual(content['meta']['total_count'], 1)
self.assertEqual(content['meta']['offset'], 0)
self.assertEqual(content['meta']['limit'], 20)
self.assertEqual(content['meta']['next'], None)
def test_update(self):
user = User()
user.email = "Bob"
user.save()
feed = Feed()
feed.link = "http://paulhummer.org/rss"
feed.save()
feed.update()
# Re-fetch the feed
feed = Feed.objects.get(pk=feed.pk)
self.assertEqual(feed.items.count(), 20)
self.assertEqual(feed.title, "Dapper as...")
self.assertTrue(feed.description.startswith("Bike rider"))
def test_malformed(self):
owner = User()
owner.email = "Bob"
owner.save()
other_owner = User()
other_owner.email = "Mike"
other_owner.save()
other_feed = Feed()
other_feed.save()
other_owner.subscribe(other_feed)
# Lack of title
title = u"rockmnkey"
link = u"http://rockmnkey.livejournal.com/data/rss"
site = u"http://rockmnkey.livejournal.com/"
feed = Feed.create_and_subscribe(title, link, site, owner)
# Duplicate entries
title = u"Canonical Voices"
link = u"http://voices.canonical.com/feed/atom/"
site = u"http://voices.canonical.com/"
feed = Feed.create_and_subscribe(title, link, site, owner)
# Lack of atom_id
title = u"aw's blog"
link = u"http://aw.lackof.org/~awilliam/blog/index.rss"
site = u"http://aw.lackof.org/~awilliam/blog/"
feed = Feed.create_and_subscribe(title, link, site, owner)
# Dead feed
title = u"Clayton - MySpace Blog"
link = u"http://blog.myspace.com/blog/rss.cfm?friendID=73367402"
site = None
feed = Feed.create_and_subscribe(title, link, site, owner)
feeds = Feed.objects.all()
self.assertEqual(feeds.count(), 5)
total_feeds = Feed.objects.all().count()
owner = User.objects.get(pk=owner.pk)
self.assertEqual(owner.feeds.count(), total_feeds - 1)
