def setUp(self): # noqa: N802
# TODO: use create_proxy helpers.
self.audio = dummy_audio.DummyAudio.start().proxy()
self.backend = TestBackend.start(audio=self.audio,
config=self.config).proxy()
self.core = core.Core(audio=self.audio,
backends=[self.backend],
config=self.config)
self.playback = self.core.playback
# We don't have a core actor running, so call about to finish directly.
self.audio.set_about_to_finish_callback(
self.playback._on_about_to_finish)
with deprecation.ignore('core.tracklist.add:tracks_arg'):
self.core.tracklist.add(self.tracks)
self.events = []
self.patcher = mock.patch('mopidy.audio.listener.AudioListener.send')
self.send_mock = self.patcher.start()
def send(event, **kwargs):
self.events.append((event, kwargs))
self.send_mock.side_effect = send
def search(context, *args):
"""
*musicpd.org, music database section:*
``search {TYPE} {WHAT} [...]``
Searches for any song that contains ``WHAT``. Parameters have the same
meaning as for ``find``, except that search is not case sensitive.
*GMPC:*
- uses the undocumented field ``any``.
- searches for multiple words like this::
search any "foo" any "bar" any "baz"
*ncmpc:*
- capitalizes the field argument.
*ncmpcpp:*
- also uses the search type "date".
- uses "file" instead of "filename".
"""
try:
query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING)
except ValueError:
return
with deprecation.ignore('core.library.search:empty_query'):
results = context.core.library.search(query).get()
artists = [_artist_as_track(a) for a in _get_artists(results)]
albums = [_album_as_track(a) for a in _get_albums(results)]
tracks = _get_tracks(results)
return translator.tracks_to_mpd_format(artists + albums + tracks)
def setup_method(self, method):
self.audio = dummy_audio.create_proxy(config=self.config, mixer=None)
self.backend = MyTestBackend.start(
audio=self.audio, config=self.config
).proxy()
self.core = core.Core(
audio=self.audio, backends=[self.backend], config=self.config
)
self.playback = self.core.playback
# We don't have a core actor running, so call about to finish directly.
self.audio.set_about_to_finish_callback(
self.playback._on_about_to_finish
)
with deprecation.ignore():
self.core.tracklist.add(self.tracks)
self.events = []
self.patcher = mock.patch("mopidy.audio.listener.AudioListener.send")
self.send_mock = self.patcher.start()
def send(event, **kwargs):
self.events.append((event, kwargs))
self.send_mock.side_effect = send
def run(self, result=None):
with deprecation.ignore(ids=[
'core.playlists.filter',
'core.playlists.filter:kwargs_criteria',
'core.playlists.get_playlists'
]):
return super(DeprecatedM3UPlaylistsProviderTest, self).run(result)
def search(context, *args):
"""
*musicpd.org, music database section:*
``search {TYPE} {WHAT} [...]``
Searches for any song that contains ``WHAT``. Parameters have the same
meaning as for ``find``, except that search is not case sensitive.
*GMPC:*
- uses the undocumented field ``any``.
- searches for multiple words like this::
search any "foo" any "bar" any "baz"
*ncmpc:*
- capitalizes the field argument.
*ncmpcpp:*
- also uses the search type "date".
- uses "file" instead of "filename".
"""
try:
query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING)
except ValueError:
return
with deprecation.ignore('core.library.search:empty_query'):
results = context.core.library.search(query).get()
artists = [_artist_as_track(a) for a in _get_artists(results)]
albums = [_album_as_track(a) for a in _get_albums(results)]
tracks = _get_tracks(results)
return translator.tracks_to_mpd_format(artists + albums + tracks)
def test_add_by_uri_looks_up_uri_in_library(self):
self.library.lookup.reset_mock()
self.core.tracklist.clear()
with deprecation.ignore('core.tracklist.add:uri_arg'):
tl_tracks = self.core.tracklist.add(uris=['dummy1:a'])
self.library.lookup.assert_called_once_with('dummy1:a')
self.assertEqual(1, len(tl_tracks))
self.assertEqual(self.tracks[0], tl_tracks[0].track)
self.assertEqual(tl_tracks, self.core.tracklist.tl_tracks[-1:])
def test_add_by_uri_looks_up_uri_in_library(self):
self.library.lookup.reset_mock()
self.core.tracklist.clear()
with deprecation.ignore('core.tracklist.add:uri_arg'):
tl_tracks = self.core.tracklist.add(uris=['dummy1:a'])
self.library.lookup.assert_called_once_with('dummy1:a')
self.assertEqual(1, len(tl_tracks))
self.assertEqual(self.tracks[0], tl_tracks[0].track)
self.assertEqual(tl_tracks, self.core.tracklist.tl_tracks[-1:])
def test_seek_fails_for_track_without_duration(self):
track = self.tracks[0].replace(length=None)
self.core.tracklist.clear()
with deprecation.ignore():
self.core.tracklist.add(tracks=[track])
self.core.playback.play()
self.replay_events()
assert not self.core.playback.seek(1000)
assert 0 == self.core.playback.get_time_position()
def setUp(self): # noqa: N802
config = {"core": {"max_tracklist_length": 10000}}
self.audio = dummy_audio.create_proxy()
self.mixer = dummy_mixer.create_proxy()
self.backend = dummy_backend.create_proxy(audio=self.audio)
with deprecation.ignore():
self.core = core.Core.start(config, audio=self.audio, mixer=self.mixer, backends=[self.backend]).proxy()
self.dispatcher = dispatcher.MpdDispatcher(core=self.core)
self.context = self.dispatcher.context
def setUp(self): # noqa: N802
config = {
'mpd': {
'password': None,
'command_blacklist': ['disabled'],
}
}
self.backend = dummy_backend.create_proxy()
self.dispatcher = MpdDispatcher(config=config)
with deprecation.ignore():
self.core = core.Core.start(backends=[self.backend]).proxy()
def setUp(self): # noqa: N802
config = {
'mpd': {
'password': None,
'command_blacklist': ['disabled'],
}
}
self.backend = dummy_backend.create_proxy()
self.dispatcher = MpdDispatcher(config=config)
with deprecation.ignore():
self.core = core.Core.start(backends=[self.backend]).proxy()
def setUp(self): # noqa: N802
config = {"core": {"max_tracklist_length": 10000}}
self.backend = dummy_backend.create_proxy()
self.backend.library.dummy_library = [
Track(uri="dummy:a"),
Track(uri="dummy:b"),
]
with deprecation.ignore():
self.core = core.Core.start(config,
backends=[self.backend]).proxy()
def test_pause_toggle(self):
self.send_request('play "0"')
self.assertEqual(PLAYING, self.core.playback.state.get())
self.assertInResponse('OK')
with deprecation.ignore('mpd.protocol.playback.pause:state_arg'):
self.send_request('pause')
self.assertEqual(PAUSED, self.core.playback.state.get())
self.assertInResponse('OK')
self.send_request('pause')
self.assertEqual(PLAYING, self.core.playback.state.get())
self.assertInResponse('OK')
def test_play(self):
self.core.tracklist.clear()
with deprecation.ignore():
self.core.tracklist.add(tracks=self.tracks_play)
self.backend.playback.reset_call_limit().get()
self.core.tracklist.set_repeat(True)
tl_tracks = self.core.tracklist.get_tl_tracks()
self.core.playback.play(tl_tracks[0])
self.replay_events()
assert not self.backend.playback.is_call_limit_reached().get()
def test_pause_toggle(self):
self.send_request('play "0"')
self.assertEqual(PLAYING, self.core.playback.state.get())
self.assertInResponse('OK')
with deprecation.ignore('mpd.protocol.playback.pause:state_arg'):
self.send_request('pause')
self.assertEqual(PAUSED, self.core.playback.state.get())
self.assertInResponse('OK')
self.send_request('pause')
self.assertEqual(PLAYING, self.core.playback.state.get())
self.assertInResponse('OK')
def test_on_about_to_finish_skips_over_change_track_unplayable(self):
# Makes translate_uri return None.
track = Track(uri="dummy:unplayable", length=1234)
with deprecation.ignore():
self.core.tracklist.add(tracks=[track], at_position=1)
tl_tracks = self.core.tracklist.get_tl_tracks()
self.core.playback.play(tl_tracks[0])
self.replay_events()
self.trigger_about_to_finish()
assert self.core.playback.get_current_tl_track() == tl_tracks[2]
def test_on_about_to_finish_skips_over_change_track_error(self):
# Trigger an exception in translate_uri.
track = Track(uri="dummy:error", length=1234)
with deprecation.ignore():
self.core.tracklist.add(tracks=[track], at_position=1)
tl_tracks = self.core.tracklist.get_tl_tracks()
self.core.playback.play(tl_tracks[0])
self.replay_events()
self.trigger_about_to_finish()
assert self.core.playback.get_current_tl_track() == tl_tracks[2]
def setUp(self): # noqa: N802
config = {
'core': {
'max_tracklist_length': 10000,
}
}
self.backend = dummy_backend.create_proxy()
self.backend.library.dummy_library = [
Track(uri='dummy:a'), Track(uri='dummy:b')]
with deprecation.ignore():
self.core = core.Core.start(
config, backends=[self.backend]).proxy()
def test_on_about_to_finish(self):
self.core.tracklist.clear()
with deprecation.ignore():
self.core.tracklist.add(tracks=self.tracks_other)
self.backend.playback.reset_call_limit().get()
self.core.tracklist.set_repeat(True)
tl_tracks = self.core.tracklist.get_tl_tracks()
self.core.playback.play(tl_tracks[1])
self.replay_events()
self.trigger_about_to_finish()
assert not self.backend.playback.is_call_limit_reached().get()
def setUp(self): # noqa: N802
config = {
'core': {
'max_tracklist_length': 10000,
}
}
self.backend = dummy_backend.create_proxy()
self.backend.library.dummy_library = [
Track(uri='dummy:a'), Track(uri='dummy:b')
]
with deprecation.ignore():
self.core = core.Core.start(config,
backends=[self.backend]).proxy()
def setUp(self): # noqa: N802
config = {
'core': {
'max_tracklist_length': 10000,
}
}
self.backend = mock.Mock()
self.backend.uri_schemes.get.return_value = ['dummy']
self.core = core.Core(config, backends=[self.backend])
self.tracks = [Track(uri='dummy:a', length=1234),
Track(uri='dummy:b', length=1234)]
with deprecation.ignore('core.tracklist.add:tracks_arg'):
self.tl_tracks = self.core.tracklist.add(tracks=self.tracks)
def get_eot_tlid(self):
"""
The TLID of the track that will be played after the current track.
Not necessarily the same TLID as returned by :meth:`get_next_tlid`.
:rtype: :class:`int` or :class:`None`
.. versionadded:: 1.1
"""
current_tl_track = self.core.playback.get_current_tl_track()
with deprecation.ignore("core.tracklist.eot_track"):
eot_tl_track = self.eot_track(current_tl_track)
return getattr(eot_tl_track, "tlid", None)
def setUp(self): # noqa: N802
config = {
'core': {
'max_tracklist_length': 10000,
}
}
self.mixer = dummy_mixer.create_proxy()
self.backend = dummy_backend.create_proxy()
with deprecation.ignore():
self.core = core.Core.start(config,
mixer=self.mixer,
backends=[self.backend]).proxy()
self.dispatcher = dispatcher.MpdDispatcher(core=self.core)
self.context = self.dispatcher.context
def test(self):
track = Track(uri="dummy:d", length=1234, name="baz")
with deprecation.ignore():
self.core.tracklist.add(tracks=[track], at_position=1)
self.core.playback.play()
self.replay_events()
self.trigger_about_to_finish(replay_until="stream_changed")
self.audio.trigger_fake_tags_changed({"title": ["foo"]}).get()
self.replay_events()
self.audio.trigger_fake_tags_changed({"title": ["baz"]}).get()
self.replay_events()
assert self.playback.get_current_track().uri == "dummy:d"
assert self.playback.get_stream_title() is None
def setUp(self): # noqa: N802
config = {
'core': {
'max_tracklist_length': 10000,
}
}
self.backend = mock.Mock()
self.backend.uri_schemes.get.return_value = ['dummy']
self.core = core.Core(config, backends=[self.backend])
self.tracks = [
Track(uri='dummy:a', length=1234),
Track(uri='dummy:b', length=1234)
]
with deprecation.ignore('core.tracklist.add:tracks_arg'):
self.tl_tracks = self.core.tracklist.add(tracks=self.tracks)
def get_previous_tlid(self):
"""
Returns the TLID of the track that will be played if calling
:meth:`mopidy.core.PlaybackController.previous()`.
For normal playback this is the previous track in the tracklist. If
random and/or consume is enabled it should return the current track
instead.
:rtype: :class:`int` or :class:`None`
.. versionadded:: 1.1
"""
current_tl_track = self.core.playback.get_current_tl_track()
with deprecation.ignore("core.tracklist.previous_track"):
previous_tl_track = self.previous_track(current_tl_track)
return getattr(previous_tl_track, "tlid", None)
def setUp(self): # noqa: N802
self.backend = dummy_backend.create_proxy()
self.calc = Calculator()
with deprecation.ignore():
self.core = core.Core.start(backends=[self.backend]).proxy()
self.jrw = jsonrpc.JsonRpcWrapper(
objects={
"hello": lambda: "Hello, world!",
"calc": self.calc,
"core": self.core,
"core.playback": self.core.playback,
"core.tracklist": self.core.tracklist,
"get_uri_schemes": self.core.get_uri_schemes,
},
encoders=[models.ModelJSONEncoder],
decoders=[models.model_json_decoder],
)
def setUp(self): # noqa: N802
self.backend = dummy_backend.create_proxy()
self.calc = Calculator()
with deprecation.ignore():
self.core = core.Core.start(backends=[self.backend]).proxy()
self.jrw = jsonrpc.JsonRpcWrapper(
objects={
"hello": lambda: "Hello, world!",
"calc": self.calc,
"core": self.core,
"core.playback": self.core.playback,
"core.tracklist": self.core.tracklist,
"get_uri_schemes": self.core.get_uri_schemes,
},
encoders=[models.ModelJSONEncoder],
decoders=[models.model_json_decoder],
)
def find(context, *args):
"""
*musicpd.org, music database section:*
``find {TYPE} {WHAT}``
Finds songs in the db that are exactly ``WHAT``. ``TYPE`` can be any
tag supported by MPD, or one of the two special parameters - ``file``
to search by full path (relative to database root), and ``any`` to
match against all available tags. ``WHAT`` is what to find.
*GMPC:*
- also uses ``find album "[ALBUM]" artist "[ARTIST]"`` to list album
tracks.
*ncmpc:*
- capitalizes the type argument.
*ncmpcpp:*
- also uses the search type "date".
- uses "file" instead of "filename".
"""
try:
query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING)
except ValueError:
return
with deprecation.ignore('core.library.search:empty_query'):
results = context.core.library.search(query=query, exact=True).get()
result_tracks = []
if ('artist' not in query and
'albumartist' not in query and
'composer' not in query and
'performer' not in query):
result_tracks += [_artist_as_track(a) for a in _get_artists(results)]
if 'album' not in query:
result_tracks += [_album_as_track(a) for a in _get_albums(results)]
result_tracks += _get_tracks(results)
return translator.tracks_to_mpd_format(result_tracks)
def setUp(self): # noqa: N802
if self.enable_mixer:
self.mixer = dummy_mixer.create_proxy()
else:
self.mixer = None
self.backend = dummy_backend.create_proxy()
with deprecation.ignore():
self.core = core.Core.start(
self.get_config(),
mixer=self.mixer,
backends=[self.backend]).proxy()
self.uri_map = uri_mapper.MpdUriMapper(self.core)
self.connection = MockConnection()
self.session = session.MpdSession(
self.connection, config=self.get_config(), core=self.core,
uri_map=self.uri_map)
self.dispatcher = self.session.dispatcher
self.context = self.dispatcher.context
def get_next_tlid(self):
"""
The tlid of the track that will be played if calling
:meth:`mopidy.core.PlaybackController.next()`.
For normal playback this is the next track in the tracklist. If repeat
is enabled the next track can loop around the tracklist. When random is
enabled this should be a random track, all tracks should be played once
before the tracklist repeats.
:rtype: :class:`int` or :class:`None`
.. versionadded:: 1.1
"""
current_tl_track = self.core.playback.get_current_tl_track()
with deprecation.ignore("core.tracklist.next_track"):
next_tl_track = self.next_track(current_tl_track)
return getattr(next_tl_track, "tlid", None)
def setUp(self): # noqa: N802
if self.enable_mixer:
self.mixer = dummy_mixer.create_proxy()
else:
self.mixer = None
self.backend = dummy_backend.create_proxy()
with deprecation.ignore():
self.core = core.Core.start(self.get_config(),
mixer=self.mixer,
backends=[self.backend]).proxy()
self.uri_map = uri_mapper.MpdUriMapper(self.core)
self.connection = MockConnection()
self.session = session.MpdSession(self.connection,
config=self.get_config(),
core=self.core,
uri_map=self.uri_map)
self.dispatcher = self.session.dispatcher
self.context = self.dispatcher.context
def findadd(context, *args):
"""
*musicpd.org, music database section:*
``findadd {TYPE} {WHAT}``
Finds songs in the db that are exactly ``WHAT`` and adds them to
current playlist. Parameters have the same meaning as for ``find``.
"""
try:
query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING)
except ValueError:
return
results = context.core.library.search(query=query, exact=True).get()
with deprecation.ignore('core.tracklist.add:tracks_arg'):
# TODO: for now just use tracks as other wise we have to lookup the
# tracks we just got from the search.
context.core.tracklist.add(tracks=_get_tracks(results)).get()
def findadd(context, *args):
"""
*musicpd.org, music database section:*
``findadd {TYPE} {WHAT}``
Finds songs in the db that are exactly ``WHAT`` and adds them to
current playlist. Parameters have the same meaning as for ``find``.
"""
try:
query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING)
except ValueError:
return
results = context.core.library.search(query=query, exact=True).get()
with deprecation.ignore('core.tracklist.add:tracks_arg'):
# TODO: for now just use tracks as other wise we have to lookup the
# tracks we just got from the search.
context.core.tracklist.add(tracks=_get_tracks(results)).get()
def swap(context, songpos1, songpos2):
"""
*musicpd.org, current playlist section:*
``swap {SONG1} {SONG2}``
Swaps the positions of ``SONG1`` and ``SONG2``.
"""
tracks = context.core.tracklist.get_tracks().get()
song1 = tracks[songpos1]
song2 = tracks[songpos2]
del tracks[songpos1]
tracks.insert(songpos1, song2)
del tracks[songpos2]
tracks.insert(songpos2, song1)
# TODO: do we need a tracklist.replace()
context.core.tracklist.clear()
with deprecation.ignore('core.tracklist.add:tracks_arg'):
context.core.tracklist.add(tracks=tracks).get()
def find(context, *args):
"""
*musicpd.org, music database section:*
``find {TYPE} {WHAT}``
Finds songs in the db that are exactly ``WHAT``. ``TYPE`` can be any
tag supported by MPD, or one of the two special parameters - ``file``
to search by full path (relative to database root), and ``any`` to
match against all available tags. ``WHAT`` is what to find.
*GMPC:*
- also uses ``find album "[ALBUM]" artist "[ARTIST]"`` to list album
tracks.
*ncmpc:*
- capitalizes the type argument.
*ncmpcpp:*
- also uses the search type "date".
- uses "file" instead of "filename".
"""
try:
query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING)
except ValueError:
return
with deprecation.ignore('core.library.search:empty_query'):
results = context.core.library.search(query=query, exact=True).get()
result_tracks = []
if ('artist' not in query and 'albumartist' not in query
and 'composer' not in query and 'performer' not in query):
result_tracks += [_artist_as_track(a) for a in _get_artists(results)]
if 'album' not in query:
result_tracks += [_album_as_track(a) for a in _get_albums(results)]
result_tracks += _get_tracks(results)
return translator.tracks_to_mpd_format(result_tracks)
def searchadd(context, *args):
"""
*musicpd.org, music database section:*
``searchadd {TYPE} {WHAT} [...]``
Searches for any song that contains ``WHAT`` in tag ``TYPE`` and adds
them to current playlist.
Parameters have the same meaning as for ``find``, except that search is
not case sensitive.
"""
try:
query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING)
except ValueError:
return
results = context.core.library.search(query).get()
with deprecation.ignore('core.tracklist.add:tracks_arg'):
# TODO: for now just use tracks as other wise we have to lookup the
# tracks we just got from the search.
context.core.tracklist.add(_get_tracks(results)).get()
def setUp(self): # noqa: N802
self.backend = dummy_backend.create_proxy()
self.calc = Calculator()
with deprecation.ignore():
self.core = core.Core.start(backends=[self.backend]).proxy()
self.jrw = jsonrpc.JsonRpcWrapper(objects={
'hello':
lambda: 'Hello, world!',
'calc':
self.calc,
'core':
self.core,
'core.playback':
self.core.playback,
'core.tracklist':
self.core.tracklist,
'get_uri_schemes':
self.core.get_uri_schemes,
},
encoders=[models.ModelJSONEncoder],
decoders=[models.model_json_decoder])
def searchadd(context, *args):
"""
*musicpd.org, music database section:*
``searchadd {TYPE} {WHAT} [...]``
Searches for any song that contains ``WHAT`` in tag ``TYPE`` and adds
them to current playlist.
Parameters have the same meaning as for ``find``, except that search is
not case sensitive.
"""
try:
query = _query_from_mpd_search_parameters(args, _SEARCH_MAPPING)
except ValueError:
return
results = context.core.library.search(query).get()
with deprecation.ignore('core.tracklist.add:tracks_arg'):
# TODO: for now just use tracks as other wise we have to lookup the
# tracks we just got from the search.
context.core.tracklist.add(_get_tracks(results)).get()
def test(self):
config = {"core": {"max_tracklist_length": 10000}}
b = mock.Mock()
b.uri_schemes.get.return_value = ["dummy"]
b.playback = mock.Mock(spec=backend.PlaybackProvider)
b.playback.change_track.return_value.get.return_value = True
b.playback.play.return_value.get.return_value = True
track1 = Track(uri="dummy:a", length=40000)
track2 = Track(uri="dummy:b", length=40000)
c = core.Core(config, mixer=None, backends=[b])
with deprecation.ignore():
c.tracklist.add(tracks=[track1, track2])
c.playback.play()
b.playback.change_track.assert_called_once_with(track1)
b.playback.change_track.reset_mock()
c.playback.pause()
c.playback.next()
b.playback.change_track.assert_called_once_with(track2)
def setUp(self): # noqa: N802
# TODO: use create_proxy helpers.
self.audio = dummy_audio.DummyAudio.start().proxy()
self.backend = TestBackend.start(
audio=self.audio, config=self.config).proxy()
self.core = core.Core(
audio=self.audio, backends=[self.backend], config=self.config)
self.playback = self.core.playback
# We don't have a core actor running, so call about to finish directly.
self.audio.set_about_to_finish_callback(
self.playback._on_about_to_finish)
with deprecation.ignore('core.tracklist.add:tracks_arg'):
self.core.tracklist.add(self.tracks)
self.events = []
self.patcher = mock.patch('mopidy.audio.listener.AudioListener.send')
self.send_mock = self.patcher.start()
def send(event, **kwargs):
self.events.append((event, kwargs))
self.send_mock.side_effect = send
def setup_method(self, method):
config = {"core": {"max_tracklist_length": 10000}}
self.backend1 = mock.Mock()
self.backend1.uri_schemes.get.return_value = ["dummy1"]
self.playback1 = mock.Mock(spec=backend.PlaybackProvider)
self.backend1.playback = self.playback1
self.backend2 = mock.Mock()
self.backend2.uri_schemes.get.return_value = ["dummy2"]
self.playback2 = mock.Mock(spec=backend.PlaybackProvider)
self.backend2.playback = self.playback2
self.tracks = [
Track(uri="dummy1:a", length=40000),
Track(uri="dummy2:a", length=40000),
]
self.core = core.Core(config,
mixer=None,
backends=[self.backend1, self.backend2])
with deprecation.ignore():
self.tl_tracks = self.core.tracklist.add(tracks=self.tracks)
def run(self, result=None):
with deprecation.ignore('core.tracklist.add:tracks_arg'):
return super(LocalPlaybackProviderTest, self).run(result)
def run(self, result=None):
with deprecation.ignore('core.tracklist.add:tracks_arg'):
return super(LocalTracklistProviderTest, self).run(result)
def run(self, result=None):
with deprecation.ignore('core.library.find_exact'):
return super(LegacyFindExactToSearchLibraryTest, self).run(result)
def run(self, result=None):
with deprecation.ignore('core.library.lookup:uri_arg'):
return super(DeprecatedLookupCoreLibraryTest, self).run(result)
def run(self, result=None):
with deprecation.ignore('core.library.find_exact'):
return super(DeprecatedFindExactCoreLibraryTest, self).run(result)
def run(self, result=None):
with deprecation.ignore(ids=['core.playlists.filter',
'core.playlists.get_playlists']):
return super(DeprecatedFilterPlaylistsTest, self).run(result)
def run(self, result=None):
with deprecation.ignore('core.playlists.get_playlists'):
return super(DeprecatedGetPlaylistsTest, self).run(result)
def test_playlist_returns_same_as_playlistinfo(self):
with deprecation.ignore('mpd.protocol.current_playlist.playlist'):
playlist_response = self.send_request('playlist')
playlistinfo_response = self.send_request('playlistinfo')
self.assertEqual(playlist_response, playlistinfo_response)
def wrapper(self):
with deprecation.ignore('core.tracklist.add:tracks_arg'):
self.tl_tracks = self.core.tracklist.add(self.tracks)
return func(self)
def run(self, result=None):
with deprecation.ignore(ids=['core.playlists.filter',
'core.playlists.filter:kwargs_criteria',
'core.playlists.get_playlists']):
return super(DeprecatedM3UPlaylistsProviderTest, self).run(result)
