andpp/mopidy
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

core: Emit deprecation warning for library.find_exact

Browse Source
This commit is contained in:
Thomas Adamcik 2015-03-26 22:45:22 +01:00
parent b31f0c421f
commit 5a3fb64250
4 changed files with 166 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
mopidy/core/library.py
View File

@ -4,6 +4,7 @@ import collections
import logging
import operator
import urlparse
import warnings
import pykka
@ -132,6 +133,7 @@ class LibraryController(object):
.. deprecated:: 1.0
Use :meth:`search` with ``exact`` set.
"""
warnings.warn('library.find_exact() is deprecated', DeprecationWarning)
return self.search(query=query, uris=uris, exact=True, **kwargs)
def lookup(self, uri=None, uris=None):

6
mopidy/mpd/protocol/music_db.py
View File

@ -100,7 +100,7 @@ def count(context, *args):
query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING)
except ValueError:
raise exceptions.MpdArgError('incorrect arguments')
results = context.core.library.find_exact(**query).get()
results = context.core.library.search(query=query, exact=True).get()
result_tracks = _get_tracks(results)
return [
('songs', len(result_tracks)),
@ -141,7 +141,7 @@ def find(context, *args):
except ValueError:
return
results = context.core.library.find_exact(**query).get()
results = context.core.library.search(query=query, exact=True).get()
result_tracks = []
if ('artist' not in query and
'albumartist' not in query and
@ -168,7 +168,7 @@ def findadd(context, *args):
query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING)
except ValueError:
return
results = context.core.library.find_exact(**query).get()
results = context.core.library.search(query=query, exact=True).get()
context.core.tracklist.add(_get_tracks(results))

162
tests/core/test_library.py
View File

@ -1,6 +1,7 @@
from __future__ import absolute_import, unicode_literals
import unittest
import warnings
import mock
@ -206,75 +207,6 @@ class CoreLibraryTest(unittest.TestCase):
self.library1.refresh.assert_called_once_with(None)
self.library2.refresh.assert_called_twice_with(None)
def test_find_exact_combines_results_from_all_backends(self):
track1 = Track(uri='dummy1:a')
track2 = Track(uri='dummy2:a')
result1 = SearchResult(tracks=[track1])
result2 = SearchResult(tracks=[track2])
self.library1.search.return_value.get.return_value = result1
self.library2.search.return_value.get.return_value = result2
result = self.core.library.find_exact(any=['a'])
self.assertIn(result1, result)
self.assertIn(result2, result)
self.library1.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
self.library2.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
def test_find_exact_with_uris_selects_dummy1_backend(self):
self.core.library.find_exact(
any=['a'], uris=['dummy1:', 'dummy1:foo', 'dummy3:'])
self.library1.search.assert_called_once_with(
query=dict(any=['a']), uris=['dummy1:', 'dummy1:foo'], exact=True)
self.assertFalse(self.library2.search.called)
def test_find_exact_with_uris_selects_both_backends(self):
self.core.library.find_exact(
any=['a'], uris=['dummy1:', 'dummy1:foo', 'dummy2:'])
self.library1.search.assert_called_once_with(
query=dict(any=['a']), uris=['dummy1:', 'dummy1:foo'], exact=True)
self.library2.search.assert_called_once_with(
query=dict(any=['a']), uris=['dummy2:'], exact=True)
def test_find_exact_filters_out_none(self):
track1 = Track(uri='dummy1:a')
result1 = SearchResult(tracks=[track1])
self.library1.search.return_value.get.return_value = result1
self.library2.search.return_value.get.return_value = None
result = self.core.library.find_exact(any=['a'])
self.assertIn(result1, result)
self.assertNotIn(None, result)
self.library1.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
self.library2.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
def test_find_accepts_query_dict_instead_of_kwargs(self):
track1 = Track(uri='dummy1:a')
track2 = Track(uri='dummy2:a')
result1 = SearchResult(tracks=[track1])
result2 = SearchResult(tracks=[track2])
self.library1.search.return_value.get.return_value = result1
self.library2.search.return_value.get.return_value = result2
result = self.core.library.find_exact(dict(any=['a']))
self.assertIn(result1, result)
self.assertIn(result2, result)
self.library1.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
self.library2.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
def test_search_combines_results_from_all_backends(self):
track1 = Track(uri='dummy1:a')
track2 = Track(uri='dummy2:a')
@ -355,8 +287,90 @@ class CoreLibraryTest(unittest.TestCase):
self.library1.search.assert_called_once_with(
query={'any': ['foobar']}, uris=None, exact=False)
class DeprecatedCoreLibraryTest(CoreLibraryTest):
def setUp(self): # noqa: N802
super(DeprecatedCoreLibraryTest, self).setUp()
self._warnings_filters = warnings.filters
warnings.filters = warnings.filters[:]
warnings.filterwarnings('ignore', '.*library.find_exact.*')
def tearDown(self): # noqa: N802
super(DeprecatedCoreLibraryTest, self).tearDown()
warnings.filters = self._warnings_filters
def test_find_exact_combines_results_from_all_backends(self):
track1 = Track(uri='dummy1:a')
track2 = Track(uri='dummy2:a')
result1 = SearchResult(tracks=[track1])
result2 = SearchResult(tracks=[track2])
self.library1.search.return_value.get.return_value = result1
self.library2.search.return_value.get.return_value = result2
result = self.core.library.find_exact(any=['a'])
self.assertIn(result1, result)
self.assertIn(result2, result)
self.library1.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
self.library2.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
def test_find_exact_with_uris_selects_dummy1_backend(self):
self.core.library.find_exact(
any=['a'], uris=['dummy1:', 'dummy1:foo', 'dummy3:'])
self.library1.search.assert_called_once_with(
query=dict(any=['a']), uris=['dummy1:', 'dummy1:foo'], exact=True)
self.assertFalse(self.library2.search.called)
def test_find_exact_with_uris_selects_both_backends(self):
self.core.library.find_exact(
any=['a'], uris=['dummy1:', 'dummy1:foo', 'dummy2:'])
self.library1.search.assert_called_once_with(
query=dict(any=['a']), uris=['dummy1:', 'dummy1:foo'], exact=True)
self.library2.search.assert_called_once_with(
query=dict(any=['a']), uris=['dummy2:'], exact=True)
def test_find_exact_filters_out_none(self):
track1 = Track(uri='dummy1:a')
result1 = SearchResult(tracks=[track1])
self.library1.search.return_value.get.return_value = result1
self.library2.search.return_value.get.return_value = None
result = self.core.library.find_exact(any=['a'])
self.assertIn(result1, result)
self.assertNotIn(None, result)
self.library1.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
self.library2.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
def test_find_accepts_query_dict_instead_of_kwargs(self):
track1 = Track(uri='dummy1:a')
track2 = Track(uri='dummy2:a')
result1 = SearchResult(tracks=[track1])
result2 = SearchResult(tracks=[track2])
self.library1.search.return_value.get.return_value = result1
self.library2.search.return_value.get.return_value = result2
result = self.core.library.find_exact(dict(any=['a']))
self.assertIn(result1, result)
self.assertIn(result2, result)
self.library1.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
self.library2.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)
def test_find_exact_normalises_bad_queries(self):
self.core.library.find_exact({'any': 'foobar'})
self.library1.search.assert_called_once_with(
query={'any': ['foobar']}, uris=None, exact=True)
@ -369,8 +383,18 @@ class LegacyFindExactToSearchLibraryTest(unittest.TestCase):
self.backend.library = mock.Mock(spec=backend.LibraryProvider)
self.core = core.Core(mixer=None, backends=[self.backend])
self._warnings_filters = warnings.filters
warnings.filters = warnings.filters[:]
warnings.filterwarnings('ignore', '.*library.find_exact.*')
def tearDown(self): # noqa: N802
warnings.filters = self._warnings_filters
def test_core_find_exact_calls_backend_search_with_exact(self):
with warnings.catch_warnings():
warnings.simplefilter('ignore')
self.core.library.find_exact(query={'any': ['a']})
self.backend.library.search.assert_called_once_with(
query=dict(any=['a']), uris=None, exact=True)

130
tests/local/test_library.py
View File

@ -84,6 +84,10 @@ class LocalLibraryProviderTest(unittest.TestCase):
pykka.ActorRegistry.stop_all()
actor.LocalBackend.libraries = []
def find_exact(self, **query):
# TODO: remove this helper?
return self.library.search(query=query, exact=True)
def test_refresh(self):
self.library.refresh()
@ -149,228 +153,228 @@ class LocalLibraryProviderTest(unittest.TestCase):
# TODO: move to search_test module
def test_find_exact_no_hits(self):
result = self.library.find_exact(track_name=['unknown track'])
result = self.find_exact(track_name=['unknown track'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(artist=['unknown artist'])
result = self.find_exact(artist=['unknown artist'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(albumartist=['unknown albumartist'])
result = self.find_exact(albumartist=['unknown albumartist'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(composer=['unknown composer'])
result = self.find_exact(composer=['unknown composer'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(performer=['unknown performer'])
result = self.find_exact(performer=['unknown performer'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(album=['unknown album'])
result = self.find_exact(album=['unknown album'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(date=['1990'])
result = self.find_exact(date=['1990'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(genre=['unknown genre'])
result = self.find_exact(genre=['unknown genre'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(track_no=['9'])
result = self.find_exact(track_no=['9'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(track_no=['no_match'])
result = self.find_exact(track_no=['no_match'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(comment=['fake comment'])
result = self.find_exact(comment=['fake comment'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(uri=['fake uri'])
result = self.find_exact(uri=['fake uri'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(any=['unknown any'])
result = self.find_exact(any=['unknown any'])
self.assertEqual(list(result[0].tracks), [])
def test_find_exact_uri(self):
track_1_uri = 'local:track:path1'
result = self.library.find_exact(uri=track_1_uri)
result = self.find_exact(uri=track_1_uri)
self.assertEqual(list(result[0].tracks), self.tracks[:1])
track_2_uri = 'local:track:path2'
result = self.library.find_exact(uri=track_2_uri)
result = self.find_exact(uri=track_2_uri)
self.assertEqual(list(result[0].tracks), self.tracks[1:2])
def test_find_exact_track_name(self):
result = self.library.find_exact(track_name=['track1'])
result = self.find_exact(track_name=['track1'])
self.assertEqual(list(result[0].tracks), self.tracks[:1])
result = self.library.find_exact(track_name=['track2'])
result = self.find_exact(track_name=['track2'])
self.assertEqual(list(result[0].tracks), self.tracks[1:2])
def test_find_exact_artist(self):
result = self.library.find_exact(artist=['artist1'])
result = self.find_exact(artist=['artist1'])
self.assertEqual(list(result[0].tracks), self.tracks[:1])
result = self.library.find_exact(artist=['artist2'])
result = self.find_exact(artist=['artist2'])
self.assertEqual(list(result[0].tracks), self.tracks[1:2])
result = self.library.find_exact(artist=['artist3'])
result = self.find_exact(artist=['artist3'])
self.assertEqual(list(result[0].tracks), self.tracks[3:4])
def test_find_exact_composer(self):
result = self.library.find_exact(composer=['artist5'])
result = self.find_exact(composer=['artist5'])
self.assertEqual(list(result[0].tracks), self.tracks[4:5])
result = self.library.find_exact(composer=['artist6'])
result = self.find_exact(composer=['artist6'])
self.assertEqual(list(result[0].tracks), [])
def test_find_exact_performer(self):
result = self.library.find_exact(performer=['artist6'])
result = self.find_exact(performer=['artist6'])
self.assertEqual(list(result[0].tracks), self.tracks[5:6])
result = self.library.find_exact(performer=['artist5'])
result = self.find_exact(performer=['artist5'])
self.assertEqual(list(result[0].tracks), [])
def test_find_exact_album(self):
result = self.library.find_exact(album=['album1'])
result = self.find_exact(album=['album1'])
self.assertEqual(list(result[0].tracks), self.tracks[:1])
result = self.library.find_exact(album=['album2'])
result = self.find_exact(album=['album2'])
self.assertEqual(list(result[0].tracks), self.tracks[1:2])
def test_find_exact_albumartist(self):
# Artist is both track artist and album artist
result = self.library.find_exact(albumartist=['artist1'])
result = self.find_exact(albumartist=['artist1'])
self.assertEqual(list(result[0].tracks), [self.tracks[0]])
# Artist is both track and album artist
result = self.library.find_exact(albumartist=['artist2'])
result = self.find_exact(albumartist=['artist2'])
self.assertEqual(list(result[0].tracks), [self.tracks[1]])
# Artist is just album artist
result = self.library.find_exact(albumartist=['artist3'])
result = self.find_exact(albumartist=['artist3'])
self.assertEqual(list(result[0].tracks), [self.tracks[2]])
def test_find_exact_track_no(self):
result = self.library.find_exact(track_no=['1'])
result = self.find_exact(track_no=['1'])
self.assertEqual(list(result[0].tracks), self.tracks[:1])
result = self.library.find_exact(track_no=['2'])
result = self.find_exact(track_no=['2'])
self.assertEqual(list(result[0].tracks), self.tracks[1:2])
def test_find_exact_genre(self):
result = self.library.find_exact(genre=['genre1'])
result = self.find_exact(genre=['genre1'])
self.assertEqual(list(result[0].tracks), self.tracks[4:5])
result = self.library.find_exact(genre=['genre2'])
result = self.find_exact(genre=['genre2'])
self.assertEqual(list(result[0].tracks), self.tracks[5:6])
def test_find_exact_date(self):
result = self.library.find_exact(date=['2001'])
result = self.find_exact(date=['2001'])
self.assertEqual(list(result[0].tracks), [])
result = self.library.find_exact(date=['2001-02-03'])
result = self.find_exact(date=['2001-02-03'])
self.assertEqual(list(result[0].tracks), self.tracks[:1])
result = self.library.find_exact(date=['2002'])
result = self.find_exact(date=['2002'])
self.assertEqual(list(result[0].tracks), self.tracks[1:2])
def test_find_exact_comment(self):
result = self.library.find_exact(
result = self.find_exact(
comment=['This is a fantastic track'])
self.assertEqual(list(result[0].tracks), self.tracks[3:4])
result = self.library.find_exact(
result = self.find_exact(
comment=['This is a fantastic'])
self.assertEqual(list(result[0].tracks), [])
def test_find_exact_any(self):
# Matches on track artist
result = self.library.find_exact(any=['artist1'])
result = self.find_exact(any=['artist1'])
self.assertEqual(list(result[0].tracks), self.tracks[:1])
result = self.library.find_exact(any=['artist2'])
result = self.find_exact(any=['artist2'])
self.assertEqual(list(result[0].tracks), self.tracks[1:2])
# Matches on track name
result = self.library.find_exact(any=['track1'])
result = self.find_exact(any=['track1'])
self.assertEqual(list(result[0].tracks), self.tracks[:1])
result = self.library.find_exact(any=['track2'])
result = self.find_exact(any=['track2'])
self.assertEqual(list(result[0].tracks), self.tracks[1:2])
# Matches on track album
result = self.library.find_exact(any=['album1'])
result = self.find_exact(any=['album1'])
self.assertEqual(list(result[0].tracks), self.tracks[:1])
# Matches on track album artists
result = self.library.find_exact(any=['artist3'])
result = self.find_exact(any=['artist3'])
self.assertEqual(len(result[0].tracks), 2)
self.assertIn(self.tracks[2], result[0].tracks)
self.assertIn(self.tracks[3], result[0].tracks)
# Matches on track composer
result = self.library.find_exact(any=['artist5'])
result = self.find_exact(any=['artist5'])
self.assertEqual(list(result[0].tracks), self.tracks[4:5])
# Matches on track performer
result = self.library.find_exact(any=['artist6'])
result = self.find_exact(any=['artist6'])
self.assertEqual(list(result[0].tracks), self.tracks[5:6])
# Matches on track genre
result = self.library.find_exact(any=['genre1'])
result = self.find_exact(any=['genre1'])
self.assertEqual(list(result[0].tracks), self.tracks[4:5])
result = self.library.find_exact(any=['genre2'])
result = self.find_exact(any=['genre2'])
self.assertEqual(list(result[0].tracks), self.tracks[5:6])
# Matches on track date
result = self.library.find_exact(any=['2002'])
result = self.find_exact(any=['2002'])
self.assertEqual(list(result[0].tracks), self.tracks[1:2])
# Matches on track comment
result = self.library.find_exact(
result = self.find_exact(
any=['This is a fantastic track'])
self.assertEqual(list(result[0].tracks), self.tracks[3:4])
# Matches on URI
result = self.library.find_exact(any=['local:track:path1'])
result = self.find_exact(any=['local:track:path1'])
self.assertEqual(list(result[0].tracks), self.tracks[:1])
def test_find_exact_wrong_type(self):
with self.assertRaises(LookupError):
self.library.find_exact(wrong=['test'])
self.find_exact(wrong=['test'])
def test_find_exact_with_empty_query(self):
with self.assertRaises(LookupError):
self.library.find_exact(artist=[''])
self.find_exact(artist=[''])
with self.assertRaises(LookupError):
self.library.find_exact(albumartist=[''])
self.find_exact(albumartist=[''])
with self.assertRaises(LookupError):
self.library.find_exact(track_name=[''])
self.find_exact(track_name=[''])
with self.assertRaises(LookupError):
self.library.find_exact(composer=[''])
self.find_exact(composer=[''])
with self.assertRaises(LookupError):
self.library.find_exact(performer=[''])
self.find_exact(performer=[''])
with self.assertRaises(LookupError):
self.library.find_exact(album=[''])
self.find_exact(album=[''])
with self.assertRaises(LookupError):
self.library.find_exact(track_no=[''])
self.find_exact(track_no=[''])
with self.assertRaises(LookupError):
self.library.find_exact(genre=[''])
self.find_exact(genre=[''])
with self.assertRaises(LookupError):
self.library.find_exact(date=[''])
self.find_exact(date=[''])
with self.assertRaises(LookupError):
self.library.find_exact(comment=[''])
self.find_exact(comment=[''])
with self.assertRaises(LookupError):
self.library.find_exact(any=[''])
self.find_exact(any=[''])
def test_search_no_hits(self):
result = self.library.search(track_name=['unknown track'])