def test_read_many(self):
fs = FeedStore()
f = self.create_feed('Feed 5', 'http://example.org/feed4/rss', 1)
feed_id = str(f.id)
fs.ensure_feed_directory(feed_id)
self.populate_feed(fs, feed_id, 10)
entries = fs.get_entries(feed_id)
self.assertEqual(10, len(entries))
remaining_count = fs.mark_read(feed_id, (e['ref'] for e in entries[0:3]))
self.assertEqual(7, remaining_count)
def test_cannot_add_entry_twice(self):
fs = FeedStore()
f = self. create_feed("MyFeed", "http://example.org/feed", 1)
feed_id = str(f.id)
fs.ensure_feed_directory(feed_id)
entry = {
'title': "Test Entry",
'published_parsed' : f.last_updated.utctimetuple(),
'guid' : 'http://example.org/feed1/?p=1'
}
fs.add_entry(feed_id, entry)
feed_counts = fs.get_feed_counts()
self.assertEqual(1, feed_counts[feed_id])
fs.add_entry(feed_id, entry)
feed_counts = fs.get_feed_counts()
self.assertEqual(1, feed_counts[feed_id])
class FeedParserTests(StoreTestCase):
def setUp(self):
StoreTestCase.setUp(self)
self.store = FeedStore()
def test_real_feed(self):
feed = self.create_feed("Techquila", "http://techquila.com/tech/feed/")
feedprocessor.process_feed(feed, self.store)
counts = self.store.get_counts(str(feed.id))
self.assertGreater(counts['unread'], 0, 'Expected more than 0 items for feed {0} after import from feed'.format(feed.id))
self.assertEqual(0, counts['keep'])
def test_read_entry(self):
fs = FeedStore()
f = self.create_feed('Feed 2', 'http://example.org/feed2/rss', 1)
feed_id = str(f.id)
fs.ensure_feed_directory(feed_id)
entry = {
'title': 'Test Entry',
'published_parsed': f.last_updated.utctimetuple(),
'guid' : 'http://example.org/feed2/?p=2'
}
fs.add_entry(feed_id, entry)
counts_before = fs.get_feed_counts()
self.assertEqual(1, counts_before[feed_id])
entry = fs.get_entries(feed_id)[0]
remaining_item_count = fs.mark_read(feed_id, entry['ref'])
self.assertEqual(0, remaining_item_count)
counts_after = fs.get_feed_counts()
self.assertEqual(0, counts_after[feed_id])
self.assertTrue(os.path.exists(os.path.join(TEST_PATH, "feeds", feed_id, 'read', entry['ref'])))
def test_add_entry(self):
fs = FeedStore()
f = self.create_feed("Feed 1", "http://example.org/feed1/rss", 1)
feed_id = str(f.id)
fs.ensure_feed_directory(feed_id)
counts_before = fs.get_feed_counts()
self.assertTrue(counts_before.has_key(feed_id))
self.assertEqual(0, counts_before[feed_id])
fs.add_entry(feed_id, {
'title': 'Test Entry',
'published_parsed': f.last_updated.utctimetuple(),
'guid': 'http://example.org/feed1/?p=1'
})
counts_after = fs.get_feed_counts()
self.assertTrue(counts_after.has_key(feed_id))
self.assertEqual(1, counts_after[feed_id])
entries = fs.get_entries(feed_id)
self.assertEqual(1, len(entries))
entry = entries[0]
self.assertEqual('http://example.org/feed1/?p=1', entry['guid'])
self.assertEqual('Test Entry', entry['title'])
self.assertTrue(entry.has_key('ref'))
def setUp(self):
StoreTestCase.setUp(self)
self.store = FeedStore()
self.import_opml('simple.opml')
for f in Feed.objects.all():
self.store.ensure_feed_directory(str(f.id))
class FeedResourceTests(StoreTestCase):
def setUp(self):
StoreTestCase.setUp(self)
self.store = FeedStore()
self.import_opml('simple.opml')
for f in Feed.objects.all():
self.store.ensure_feed_directory(str(f.id))
def test_get_one(self):
# setup
self.populate_feed(self.store, "1", 1)
client = self.default_login()
response = client.get('/reader/subscriptions/1')
self.assertEqual(200, response.status_code)
data = json.loads(response.content)
self.assertEqual(1, len(data))
self.assertEqual('Test Entry', data[0]['title'])
def test_login_required(self):
self.populate_feed(self.store, "1", 1)
client = Client()
response = client.get('/reader/subscriptions/1')
self.assertEqual(302, response.status_code)
def test_correct_login_required(self):
self.populate_feed(self.store, "1", 1)
client = self.other_login()
response = client.get('/reader/subscriptions/1')
self.assertEqual(401, response.status_code)
def test_get_many(self):
self.populate_feed(self.store, "1", 10)
client = self.default_login()
response = client.get('/reader/subscriptions/1')
self.assertEqual(200, response.status_code)
data = json.loads(response.content)
self.assertEqual(10, len(data))
def test_read_one(self):
self.populate_feed(self.store, "1", 10)
client = self.default_login()
response = client.get('/reader/subscriptions/1')
self.assertEqual(200, response.status_code)
entries = json.loads(response.content)
self.assertEqual(10, len(entries))
update = {'read': [entries[0]['ref']]}
response = client.post('/reader/subscriptions/1', json.dumps(update), 'application/json',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(200, response.status_code)
response = client.get('/reader/subscriptions/1')
self.assertEqual(200, response.status_code)
entries = json.loads(response.content)
self.assertEqual(9, len(entries))
def test_correct_login_required_to_update(self):
self.populate_feed(self.store, "1", 10)
client = self.other_login()
update = {'read': '12345'}
response = client.post('/reader/subscriptions/1', json.dumps(update), 'application/json',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(401, response.status_code)
def test_read_many(self):
self.populate_feed(self.store, "1", 10)
client = self.default_login()
response = client.get('/reader/subscriptions/1')
self.assertEqual(200, response.status_code)
entries = json.loads(response.content)
self.assertEqual(10, len(entries))
update = {'read': []}
for e in entries:
update['read'].append(e['ref'])
response = client.post('/reader/subscriptions/1', json.dumps(update), 'application/json',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
responseData = json.loads(response.content)
self.assertEqual(0, responseData['unread_count'])
self.assertEqual(200, response.status_code)
response = client.get('/reader/subscriptions/1')
self.assertEqual(200, response.status_code)
entries = json.loads(response.content)
self.assertEqual(0, len(entries))
def test_read_all(self):
self.populate_feed(self.store, "1", 10)
client = self.default_login()
update = {'read_all' : -1}
response = client.post('/reader/subscriptions/1', json.dumps(update), 'application/json',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(200, response.status_code)
response = client.get('/reader/subscriptions/1')
self.assertEqual(200, response.status_code)
entries = json.loads(response.content)
self.assertEqual(0, len(entries))
def test_restore_all(self):
self.populate_feed(self.store, "1", 10)
self.store.mark_all_read("1")
client = self.default_login()
entries = self.__get_entries(client, "1")
self.assertEqual(0, len(entries))
update = {'restore_all': 1}
response = client.post('/reader/subscriptions/1', json.dumps(update), 'application/json',
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(200, response.status_code)
entries = json.loads(response.content)
self.assertEqual(10, len(entries))
def __get_entries(self, client, feed_id = "1"):
response = client.get('/reader/subscriptions/' + feed_id)
self.assertEqual(200, response.status_code)
return json.loads(response.content)
def setUp(self):
StoreTestCase.setUp(self)
self.store = FeedStore()
def test_read_all_and_restore(self):
fs = FeedStore()
f = self.create_feed('Feed 4', 'http://example.org/feed4/rss', 1)
feed_id = str(f.id)
fs.ensure_feed_directory(feed_id)
self.populate_feed(fs, feed_id, 10)
entries = fs.get_entries(feed_id)
self.assertEqual(10, len(entries))
# Restore when no items unread should make no difference
fs.restore_all_items(feed_id)
entries = fs.get_entries(feed_id)
self.assertEqual(10, len(entries))
# Read one item then restore them all
fs.mark_read(feed_id, entries[0]['ref'])
self.assertEqual(9, len(fs.get_entries(feed_id)))
fs.restore_all_items(feed_id)
entries = fs.get_entries(feed_id)
self.assertEqual(10, len(entries))
# Read all items
fs.mark_all_read(feed_id)
entries = fs.get_entries(feed_id)
self.assertEqual(0, len(entries))
# Restore all items
fs.restore_all_items(feed_id)
entries = fs.get_entries(feed_id)
self.assertEqual(10, len(entries))
def test_keep_unread(self):
fs = FeedStore()
f = self.create_feed('Feed 3', 'http://example.org/feed3/rss', 1)
feed_id = str(f.id)
fs.ensure_feed_directory(feed_id)
self.populate_feed(fs, feed_id, 2)
entries = fs.get_entries(feed_id)
self.assertEqual(2, len(entries))
fs.keep(feed_id, entries[0]['ref'])
fs.mark_read(feed_id, entries[0]['ref']) # should have no effect
fs.mark_read(feed_id, entries[1]['ref']) # should delete entry not in kept directory
entries = fs.get_entries(feed_id) # should return the 1 kept item
self.assertEqual(1, len(entries))
fs.unkeep(feed_id, entries[0]['ref']) # will restore item back to feed directory
entries = fs.get_entries(feed_id) # should return 1 item from the feed directory
self.assertEqual(1, len(entries))
fs.mark_read(feed_id, entries[0]['ref']) # should delete entry
entries = fs.get_entries(feed_id)
self.assertEqual(0, len(entries))
def feed(request, feed_id='0'):
store = FeedStore()
try:
feed = Feed.objects.get(id=int(feed_id))
except Feed.DoesNotExist:
print "Cannot find the feed"
return Http404
if not feed.owner_id == request.user.id:
return HttpResponse('Unauthorized', status=401)
if request.method == "GET":
skip = 0
take = None
if request.GET.has_key('skip'):
skip = int(request.GET['skip'])
if request.GET.has_key('take'):
take = int(request.GET['take'])
entries = store.get_entries(feed_id, skip=skip, take=take)
return HttpResponse(json.dumps(entries, cls=TimeHandlingEncoder), mimetype='application/json')
elif request.method == "POST":
data = request.read()
feed_update = json.loads(data)
store = FeedStore()
responseData = {}
if 'keep' in feed_update:
for item in feed_update['keep']:
try:
store.keep(feed_id, item)
except EntryDoesNotExist:
pass;
if 'unkeep' in feed_update:
for item in feed_update['unkeep']:
try:
store.unkeep(feed_id, item)
except EntryDoesNotExist:
pass;
if 'read' in feed_update:
feed.unread_count = store.mark_read(feed_id, feed_update['read'])
feed.save()
responseData['unread_count'] = feed.unread_count
if 'read_all' in feed_update:
if feed_update['read_all'] < 0:
store.mark_all_read(feed_id)
feed.unread_count = 0
feed.save()
if 'restore_all' in feed_update:
store.restore_all_items(feed_id)
entries = store.get_entries(feed_id)
return HttpResponse(json.dumps(entries, cls=TimeHandlingEncoder), mimetype='application/json')
if 'refresh' in feed_update:
feedprocessor.process_feed(feed_id)
entries = store.get_entries(feed_id)
return HttpResponse(json.dumps(entries, cls=TimeHandlingEncoder), mimetype='application/json')
return HttpResponse(json.dumps(responseData))
elif request.method == "DELETE":
feed.is_deleted = True
feed.save()
#if 'tag' in feed_update:
# for item_tag in feed_update['tag']:
# store.tag_item(item_tag['item'], item_tag['tag'])
return HttpResponse()
