def test_feed_conditions(self):
# change the query to something that involves downloader columns
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed.orig_url', '=', self.tracked_feed.orig_url)
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items()
def test_search_for_torrent(self):
# test searching for the string "torrent" in this case, we should
# match items that are torrents.
item1 = self.tracked_items[0]
# item1 will be a torrent download
item1.download()
downloader.RemoteDownloader.update_status({
'current_size':
0,
'total_size':
None,
'state':
u'downloading',
'rate':
0,
'eta':
None,
'type':
'BitTorrent',
'dlid':
item1.downloader.dlid,
})
app.db.finish_transaction()
self.check_items_changed_after_message([item1])
# a search for torrent should match both of them
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.tracked_feed.id)
query.set_search('torrent')
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items([item1])
def test_downloader_order(self):
downloads = self.tracked_items[:4]
for i, item_ in enumerate(downloads):
# simulate a the download being in progress
item_.download()
# ensure that the downloads goes from slowest to fastest
rate = i * 1024
fake_status = {
'current_size': 0,
'total_size': None,
'state': u'downloading',
'rate': rate,
'eta': None,
'type': 'HTTP',
'dlid': item_.downloader.dlid,
}
downloader.RemoteDownloader.update_status(fake_status)
app.db.finish_transaction()
self.check_items_changed_after_message(downloads)
query = itemtrack.ItemTrackerQuery()
query.add_condition('remote_downloader.state', '=', 'downloading')
query.set_order_by(['remote_downloader.rate'])
self.tracker.change_query(query)
# Need to manually fetch the items to compare to
with self.connection_pool.context() as connection:
id_list = [i.id for i in downloads]
correct_items = item.fetch_item_infos(connection, id_list)
self.check_tracker_items(correct_items)
def test_order(self):
# test order by a different column
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.tracked_feed.id)
query.set_order_by(['title'])
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items()
# test reverse ordering
query.set_order_by(['-title'])
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items()
# test order by multiple column
query.set_order_by(['title', '-release_date'])
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items()
# test order by something more complex. Move item0 to the bottom of
# the list, then sort alphabetically
sql = ("CASE "
"WHEN title LIKE '%item0' THEN 'zzzzzz' "
"ELSE title "
"END")
query.set_complex_order_by(['title'], sql)
self.tracker.change_query(query)
self.check_one_signal('list-changed')
correct_order = self.tracked_items[1:] + self.tracked_items[:1]
self.check_tracker_items(correct_order, sort_items=False)
def _recently_played_tracker(self, file_type):
query = itemtrack.ItemTrackerQuery()
query.add_condition('file_type', '=', file_type)
query.add_condition('watched_time', 'IS NOT', None)
query.set_order_by(['-last_watched'])
query.set_limit(self.ITEM_LIMIT)
return itemtrack.ItemTracker(call_on_ui_thread, query,
item.ItemSource())
def test_like(self):
# test adding more conditions
query = itemtrack.ItemTrackerQuery()
query.add_condition('title', 'LIKE', '%feed1%')
self.tracker.change_query(query)
# changing the query should emit list-changed
self.check_one_signal('list-changed')
self.check_tracker_items()
def _recently_downloaded_tracker(self):
query = itemtrack.ItemTrackerQuery()
query.add_condition('downloaded_time', 'IS NOT', None)
query.add_condition('expired', '=', False)
query.add_condition('parent_id', 'IS', None)
query.add_condition('watched_time', 'IS', None)
query.set_order_by(['-downloaded_time'])
query.set_limit(self.ITEM_LIMIT)
return itemtrack.ItemTracker(call_on_ui_thread, query,
item.ItemSource())
def test_search(self):
# test full-text search
# manually set some titles so that we can test searching those
item1, item2, item3 = self.tracked_items[:3]
item1.title = u'foo bar'
item1.signal_change()
item2.title = u'bar baz'
item2.signal_change()
item3.title = u'foo bar baz'
item3.signal_change()
app.db.finish_transaction()
self.check_items_changed_after_message([item1, item2, item3])
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.tracked_feed.id)
query.set_search('foo')
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items([item1, item3])
# test two terms
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.tracked_feed.id)
query.set_search('foo baz')
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items([item3])
# test that we do a prefix search for the last term
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.tracked_feed.id)
query.set_search('fo')
query.set_order_by(['release_date'])
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items([item1, item3])
# But we should'nt do a prefix search for terms other than the last
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.tracked_feed.id)
query.set_search('fo bar')
query.set_order_by(['release_date'])
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items([])
def make_tracker(self):
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.feed.id)
query.set_order_by(['release_date'])
item_tracker = itemtrack.ItemTracker(self.idle_scheduler, query,
item.ItemSource())
self.list_changed_callback = mock.Mock()
self.items_changed_callback = mock.Mock()
item_tracker.connect('list-changed', self.list_changed_callback)
item_tracker.connect('items-changed', self.items_changed_callback)
return item_tracker
def test_change_query(self):
new_query = itemtrack.ItemTrackerQuery()
new_query.add_condition('feed_id', '=', self.other_feed.id)
self.item_tracker.change_query(new_query)
self.assertSameSet(self.item_tracker.get_items(),
self.fetch_item_infos(self.other_items))
# check that changing the query resulted in the items-changed signal
self.process_item_changes()
self.check_callback(added=self.other_items,
changed=[],
removed=self.items)
def test_complex_conditions(self):
# test adding more conditions
query = itemtrack.ItemTrackerQuery()
sql = "feed_id IN (SELECT id FROM feed WHERE id in (?, ?))"
values = (self.tracked_feed.id, self.other_feed1.id)
query.add_complex_condition("feed_id", sql, values)
query.set_order_by(['release_date'])
self.tracker.change_query(query)
# changing the query should emit list-changed
self.check_one_signal('list-changed')
self.check_tracker_items(self.tracked_items + self.other_items1)
def test_extra_conditions(self):
# test adding more conditions
titles = [i.title for i in self.tracked_items]
titles.sort()
middle_title = titles[len(titles) // 2]
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.tracked_feed.id)
query.add_condition('title', '<', middle_title)
query.set_order_by(['release_date'])
self.tracker.change_query(query)
# changing the query should emit list-changed
self.check_one_signal('list-changed')
self.check_tracker_items()
def test_limit(self):
# test order by a different column
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.tracked_feed.id)
query.set_order_by(['title'])
query.set_limit(3)
self.tracker.change_query(query)
self.check_one_signal('list-changed')
sorted_items = sorted(self.tracked_items, key=lambda item: item.title)
self.check_tracker_items(sorted_items[:3])
# test changes
last_item = sorted_items[-1]
last_item.title = u'aaaaaa'
last_item.signal_change()
self.check_list_change_after_message()
self.check_tracker_items([last_item] + sorted_items[:2])
def test_downloader_conditions(self):
# change the query to something that involves downloader columns
query = itemtrack.ItemTrackerQuery()
query.add_condition('remote_downloader.state', '=', 'downloading')
self.tracker.change_query(query)
self.check_one_signal('list-changed')
# start downloading some items
downloads = self.tracked_items[:4]
for i in downloads:
i.download()
self.check_list_change_after_message()
self.check_tracker_items()
for i in downloads[2:]:
i.expire()
self.check_list_change_after_message()
self.check_tracker_items()
def test_order(self):
# test order by a different column
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.tracked_feed.id)
query.set_order_by(['title'])
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items()
# test reverse ordering
query.set_order_by(['-title'])
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items()
# test order by multiple column
query.set_order_by(['title', '-release_date'])
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items()
def test_playlist_conditions(self):
# change the query to something that involves playlist columns
playlist = models.SavedPlaylist(u'My playlist')
for item in self.tracked_items:
playlist.add_item(item)
app.db.finish_transaction()
query = itemtrack.ItemTrackerQuery()
query.add_condition('playlist_item_map.playlist_id', '=', playlist.id)
self.tracker.change_query(query)
self.check_one_signal('list-changed')
self.check_tracker_items(self.tracked_items)
# add items to the playlist
new_items = self.other_items1[:4]
for item in new_items:
playlist.add_item(item)
self.check_list_change_after_message()
self.check_tracker_items(self.tracked_items + new_items)
# remove items from the playlist
removed_items = self.tracked_items[:4]
for item in removed_items:
playlist.remove_item(item)
self.check_list_change_after_message()
self.check_tracker_items(self.tracked_items[4:] + new_items)
def _make_base_query(self, tab_type, tab_id):
if self.is_for_device():
query = itemtrack.DeviceItemTrackerQuery()
elif self.is_for_share():
query = itemtrack.SharingItemTrackerQuery()
else:
query = itemtrack.ItemTrackerQuery()
if tab_type == 'videos':
query.add_condition('file_type', '=', 'video')
elif tab_type == 'music':
query.add_condition('file_type', '=', 'audio')
elif tab_type == 'others':
query.add_condition('file_type', '=', 'other')
elif tab_type == 'search':
query.add_condition('feed.orig_url', '=', 'dtv:search')
elif tab_type == 'downloading':
# FIXME: this should also include failed downloads from the manual
# feed
sql = ("remote_downloader.state IN ('downloading', 'uploading', "
"'paused', 'uploading-paused', 'offline')")
query.add_complex_condition('remote_downloader.state', sql, ())
elif tab_type == 'feed':
query.add_condition('feed_id', '=', tab_id)
elif tab_type == 'feed-folder' and tab_id == 'feed-base-tab':
# all feeds tab
query.add_condition('feed.orig_url', 'IS NOT', None)
query.add_condition('feed.orig_url', '!=', 'dtv:manualFeed')
query.add_condition('feed.orig_url', 'NOT LIKE', 'dtv:search%')
elif tab_type == 'feed-folder':
# NOTE: this also depends on the folder_id column of feed, but we
# don't track that in any way. If that changed while the user was
# viewing the display, then they wouldn't see the changes.
# However, the only way for this to change is drag and drop, so we
# can ignore this.
sql = ("feed_id in "
"(SELECT feed.id FROM feed WHERE feed.folder_id=?)")
query.add_complex_condition('feed_id', sql, (tab_id, ))
elif tab_type == 'folder-contents':
query.add_condition('parent_id', '=', tab_id)
elif tab_type == 'device-video':
query.add_condition('file_type', '=', u'video')
elif tab_type == 'device-audio':
query.add_condition('file_type', '=', u'audio')
elif tab_type == 'sharing' and tab_id.startswith("sharing-"):
# browsing a playlist on a share
id_components = tab_id.split("-")
if len(id_components) == 2:
# browsing an entire share, no filters needed
pass
else:
# browsing a playlist
playlist_id = id_components[-1]
if playlist_id == 'audio':
query.add_condition('file_type', '=', u'audio')
elif playlist_id == 'video':
query.add_condition('file_type', '=', u'video')
elif playlist_id == 'podcast':
query.add_condition(
'sharing_item_playlist_map.playlist_id', '=',
u'podcast')
elif playlist_id == 'playlist':
query.add_condition(
'sharing_item_playlist_map.playlist_id', '=',
u'playlist')
else:
query.add_condition(
'sharing_item_playlist_map.playlist_id', '=',
int(playlist_id))
elif tab_type == 'sharing':
# browsing an entire share, we don't need any filters on the query
pass
elif tab_type == 'manual':
# for the manual tab, tab_id is a list of ids to play
id_list = tab_id
placeholders = ",".join("?" for i in xrange(len(id_list)))
sql = "item.id IN (%s)" % placeholders
query.add_complex_condition('item.id', sql, id_list)
else:
raise ValueError("Can't handle tab (%r, %r)" % (tab_type, tab_id))
return query
def setup_tracker(self):
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.feed.id)
self.item_tracker = itemtrack.BackendItemTracker(query)
self.items_changed_callback = mock.Mock()
self.item_tracker.connect('items-changed', self.items_changed_callback)
def setup_tracker(self):
query = itemtrack.ItemTrackerQuery()
query.add_condition('feed_id', '=', self.tracked_feed.id)
query.set_order_by(['release_date'])
self.tracker = itemtrack.ItemTracker(self.idle_scheduler, query,
item.ItemSource())
