diff --git a/mopidy/__main__.py b/mopidy/__main__.py index c82510d9..ee2e21b6 100644 --- a/mopidy/__main__.py +++ b/mopidy/__main__.py @@ -31,6 +31,7 @@ sys.path.insert(0, from mopidy import (get_version, settings, OptionalDependencyError, SettingsError, DATA_PATH, SETTINGS_PATH, SETTINGS_FILE) from mopidy.audio import Audio +from mopidy.core import Core from mopidy.utils import get_class from mopidy.utils.deps import list_deps_optparse_callback from mopidy.utils.log import setup_logging @@ -52,7 +53,8 @@ def main(): check_old_folders() setup_settings(options.interactive) audio = setup_audio() - setup_backend(audio) + backend = setup_backend(audio) + setup_core(audio, backend) setup_frontends() loop.run() except SettingsError as e: @@ -64,6 +66,7 @@ def main(): finally: loop.quit() stop_frontends() + stop_core() stop_backend() stop_audio() stop_remaining_actors() @@ -126,13 +129,21 @@ def stop_audio(): def setup_backend(audio): - get_class(settings.BACKENDS[0]).start(audio=audio) + return get_class(settings.BACKENDS[0]).start(audio=audio).proxy() def stop_backend(): stop_actors_by_class(get_class(settings.BACKENDS[0])) +def setup_core(audio, backend): + return Core.start(audio, backend).proxy() + + +def stop_core(): + stop_actors_by_class(Core) + + def setup_frontends(): for frontend_class_name in settings.FRONTENDS: try: diff --git a/mopidy/audio/__init__.py b/mopidy/audio/__init__.py index df5efb92..3ce459dd 100644 --- a/mopidy/audio/__init__.py +++ b/mopidy/audio/__init__.py @@ -8,8 +8,7 @@ import logging from pykka.actor import ThreadingActor from pykka.registry import ActorRegistry -from mopidy import settings, utils -from mopidy.backends.base import Backend +from mopidy import core, settings, utils from mopidy.utils import process # Trigger install of gst mixer plugins @@ -150,7 +149,7 @@ class Audio(ThreadingActor): def _on_message(self, bus, message): if message.type == gst.MESSAGE_EOS: - self._notify_backend_of_eos() + self._notify_core_of_eos() elif message.type == gst.MESSAGE_ERROR: error, debug = message.parse_error() logger.error(u'%s %s', error, debug) @@ -159,14 +158,14 @@ class Audio(ThreadingActor): error, debug = message.parse_warning() logger.warning(u'%s %s', error, debug) - def _notify_backend_of_eos(self): - backend_refs = ActorRegistry.get_by_class(Backend) - assert len(backend_refs) <= 1, 'Expected at most one running backend.' - if backend_refs: - logger.debug(u'Notifying backend of end-of-stream.') - backend_refs[0].proxy().playback.on_end_of_track() + def _notify_core_of_eos(self): + core_refs = ActorRegistry.get_by_class(core.Core) + assert len(core_refs) <= 1, 'Expected at most one running core instance' + if core_refs: + logger.debug(u'Notifying core of end-of-stream') + core_refs[0].proxy().playback.on_end_of_track() else: - logger.debug(u'No backend to notify of end-of-stream found.') + logger.debug(u'No core instance to notify of end-of-stream found') def set_uri(self, uri): """ diff --git a/mopidy/backends/base/__init__.py b/mopidy/backends/base/__init__.py index 67a3c5ba..4e0f0b08 100644 --- a/mopidy/backends/base/__init__.py +++ b/mopidy/backends/base/__init__.py @@ -10,24 +10,20 @@ class Backend(object): #: which will then set this field. audio = None - #: The current playlist controller. An instance of - #: :class:`mopidy.backends.base.CurrentPlaylistController`. - current_playlist = None - - #: The library controller. An instance of - # :class:`mopidy.backends.base.LibraryController`. + #: The library provider. An instance of + # :class:`mopidy.backends.base.BaseLibraryProvider`. library = None - #: The playback controller. An instance of - #: :class:`mopidy.backends.base.PlaybackController`. + #: The playback provider. An instance of + #: :class:`mopidy.backends.base.BasePlaybackProvider`. playback = None - #: The stored playlists controller. An instance of - #: :class:`mopidy.backends.base.StoredPlaylistsController`. + #: The stored playlists provider. An instance of + #: :class:`mopidy.backends.base.BaseStoredPlaylistsProvider`. stored_playlists = None #: List of URI schemes this backend can handle. uri_schemes = [] - def __init__(self, audio=None): + def __init__(self, audio): self.audio = audio diff --git a/mopidy/backends/dummy/__init__.py b/mopidy/backends/dummy/__init__.py index 9c4a0e69..1d69ed7c 100644 --- a/mopidy/backends/dummy/__init__.py +++ b/mopidy/backends/dummy/__init__.py @@ -1,6 +1,5 @@ from pykka.actor import ThreadingActor -from mopidy import core from mopidy.backends import base from mopidy.models import Playlist @@ -14,21 +13,11 @@ class DummyBackend(ThreadingActor, base.Backend): """ def __init__(self, *args, **kwargs): - super(DummyBackend, self).__init__(*args, **kwargs) + base.Backend.__init__(self, *args, **kwargs) - self.current_playlist = core.CurrentPlaylistController(backend=self) - - library_provider = DummyLibraryProvider(backend=self) - self.library = core.LibraryController(backend=self, - provider=library_provider) - - playback_provider = DummyPlaybackProvider(backend=self) - self.playback = core.PlaybackController(backend=self, - provider=playback_provider) - - stored_playlists_provider = DummyStoredPlaylistsProvider(backend=self) - self.stored_playlists = core.StoredPlaylistsController(backend=self, - provider=stored_playlists_provider) + self.library = DummyLibraryProvider(backend=self) + self.playback = DummyPlaybackProvider(backend=self) + self.stored_playlists = DummyStoredPlaylistsProvider(backend=self) self.uri_schemes = [u'dummy'] diff --git a/mopidy/backends/local/__init__.py b/mopidy/backends/local/__init__.py index 73e10918..f3e86679 100644 --- a/mopidy/backends/local/__init__.py +++ b/mopidy/backends/local/__init__.py @@ -6,7 +6,7 @@ import shutil from pykka.actor import ThreadingActor -from mopidy import audio, core, settings +from mopidy import settings from mopidy.backends import base from mopidy.models import Playlist, Track, Album @@ -33,19 +33,9 @@ class LocalBackend(ThreadingActor, base.Backend): def __init__(self, *args, **kwargs): base.Backend.__init__(self, *args, **kwargs) - self.current_playlist = core.CurrentPlaylistController(backend=self) - - self.library_provider = LocalLibraryProvider(backend=self) - self.library = core.LibraryController(backend=self, - provider=self.library_provider) - - playback_provider = base.BasePlaybackProvider(backend=self) - self.playback = core.PlaybackController(backend=self, - provider=playback_provider) - - stored_playlists_provider = LocalStoredPlaylistsProvider(backend=self) - self.stored_playlists = core.StoredPlaylistsController(backend=self, - provider=stored_playlists_provider) + self.library = LocalLibraryProvider(backend=self) + self.playback = base.BasePlaybackProvider(backend=self) + self.stored_playlists = LocalStoredPlaylistsProvider(backend=self) self.uri_schemes = [u'file'] @@ -69,7 +59,7 @@ class LocalStoredPlaylistsProvider(base.BaseStoredPlaylistsProvider): tracks = [] for uri in parse_m3u(m3u, settings.LOCAL_MUSIC_PATH): try: - tracks.append(self.backend.library_provider.lookup(uri)) + tracks.append(self.backend.library.lookup(uri)) except LookupError, e: logger.error('Playlist item could not be added: %s', e) playlist = Playlist(tracks=tracks, name=name) diff --git a/mopidy/backends/spotify/__init__.py b/mopidy/backends/spotify/__init__.py index 4320d723..a79168f5 100644 --- a/mopidy/backends/spotify/__init__.py +++ b/mopidy/backends/spotify/__init__.py @@ -2,7 +2,7 @@ import logging from pykka.actor import ThreadingActor -from mopidy import audio, core, settings +from mopidy import settings from mopidy.backends import base logger = logging.getLogger('mopidy.backends.spotify') @@ -48,20 +48,9 @@ class SpotifyBackend(ThreadingActor, base.Backend): base.Backend.__init__(self, *args, **kwargs) - self.current_playlist = core.CurrentPlaylistController(backend=self) - - library_provider = SpotifyLibraryProvider(backend=self) - self.library = core.LibraryController(backend=self, - provider=library_provider) - - playback_provider = SpotifyPlaybackProvider(backend=self) - self.playback = core.PlaybackController(backend=self, - provider=playback_provider) - - self.stored_playlists_provider = SpotifyStoredPlaylistsProvider( - backend=self) - self.stored_playlists = core.StoredPlaylistsController(backend=self, - provider=self.stored_playlists_provider) + self.library = SpotifyLibraryProvider(backend=self) + self.playback = SpotifyPlaybackProvider(backend=self) + self.stored_playlists = SpotifyStoredPlaylistsProvider(backend=self) self.uri_schemes = [u'spotify'] diff --git a/mopidy/backends/spotify/library.py b/mopidy/backends/spotify/library.py index 3931aece..18276ecd 100644 --- a/mopidy/backends/spotify/library.py +++ b/mopidy/backends/spotify/library.py @@ -66,7 +66,7 @@ class SpotifyLibraryProvider(BaseLibraryProvider): # Since we can't search for the entire Spotify library, we return # all tracks in the stored playlists when the query is empty. tracks = [] - for playlist in self.backend.stored_playlists_provider.playlists: + for playlist in self.backend.stored_playlists.playlists: tracks += playlist.tracks return Playlist(tracks=tracks) spotify_query = [] diff --git a/mopidy/backends/spotify/session_manager.py b/mopidy/backends/spotify/session_manager.py index a6389048..52769d84 100644 --- a/mopidy/backends/spotify/session_manager.py +++ b/mopidy/backends/spotify/session_manager.py @@ -138,7 +138,7 @@ class SpotifySessionManager(BaseThread, PyspotifySessionManager): playlists = map(SpotifyTranslator.to_mopidy_playlist, self.session.playlist_container()) playlists = filter(None, playlists) - self.backend.stored_playlists_provider.playlists = playlists + self.backend.stored_playlists.playlists = playlists logger.info(u'Loaded %d Spotify playlist(s)', len(playlists)) def search(self, query, queue): diff --git a/mopidy/core/__init__.py b/mopidy/core/__init__.py index 87df96c9..6070dcc8 100644 --- a/mopidy/core/__init__.py +++ b/mopidy/core/__init__.py @@ -1,3 +1,4 @@ +from .actor import Core from .current_playlist import CurrentPlaylistController from .library import LibraryController from .playback import PlaybackController, PlaybackState diff --git a/mopidy/core/actor.py b/mopidy/core/actor.py new file mode 100644 index 00000000..4ff378c4 --- /dev/null +++ b/mopidy/core/actor.py @@ -0,0 +1,42 @@ +from pykka.actor import ThreadingActor + +from .current_playlist import CurrentPlaylistController +from .library import LibraryController +from .playback import PlaybackController +from .stored_playlists import StoredPlaylistsController + + +class Core(ThreadingActor): + #: The current playlist controller. An instance of + #: :class:`mopidy.core.CurrentPlaylistController`. + current_playlist = None + + #: The library controller. An instance of + # :class:`mopidy.core.LibraryController`. + library = None + + #: The playback controller. An instance of + #: :class:`mopidy.core.PlaybackController`. + playback = None + + #: The stored playlists controller. An instance of + #: :class:`mopidy.core.StoredPlaylistsController`. + stored_playlists = None + + def __init__(self, audio=None, backend=None): + self._backend = backend + + self.current_playlist = CurrentPlaylistController(core=self) + + self.library = LibraryController(backend=backend, core=self) + + self.playback = PlaybackController( + audio=audio, backend=backend, core=self) + + self.stored_playlists = StoredPlaylistsController( + backend=backend, core=self) + + @property + def uri_schemes(self): + """List of URI schemes we can handle""" + return self._backend.uri_schemes.get() diff --git a/mopidy/core/current_playlist.py b/mopidy/core/current_playlist.py index af06e05e..a39b4c39 100644 --- a/mopidy/core/current_playlist.py +++ b/mopidy/core/current_playlist.py @@ -17,8 +17,8 @@ class CurrentPlaylistController(object): pykka_traversable = True - def __init__(self, backend): - self.backend = backend + def __init__(self, core): + self.core = core self.cp_id = 0 self._cp_tracks = [] self._version = 0 @@ -59,7 +59,7 @@ class CurrentPlaylistController(object): @version.setter def version(self, version): self._version = version - self.backend.playback.on_current_playlist_change() + self.core.playback.on_current_playlist_change() self._trigger_playlist_changed() def add(self, track, at_position=None, increase_version=True): diff --git a/mopidy/core/library.py b/mopidy/core/library.py index fc55aaeb..52f85b55 100644 --- a/mopidy/core/library.py +++ b/mopidy/core/library.py @@ -8,9 +8,9 @@ class LibraryController(object): pykka_traversable = True - def __init__(self, backend, provider): + def __init__(self, backend, core): self.backend = backend - self.provider = provider + self.core = core def find_exact(self, **query): """ @@ -29,7 +29,7 @@ class LibraryController(object): :type query: dict :rtype: :class:`mopidy.models.Playlist` """ - return self.provider.find_exact(**query) + return self.backend.library.find_exact(**query).get() def lookup(self, uri): """ @@ -39,7 +39,7 @@ class LibraryController(object): :type uri: string :rtype: :class:`mopidy.models.Track` or :class:`None` """ - return self.provider.lookup(uri) + return self.backend.library.lookup(uri).get() def refresh(self, uri=None): """ @@ -48,7 +48,7 @@ class LibraryController(object): :param uri: directory or track URI :type uri: string """ - return self.provider.refresh(uri) + return self.backend.library.refresh(uri).get() def search(self, **query): """ @@ -67,4 +67,4 @@ class LibraryController(object): :type query: dict :rtype: :class:`mopidy.models.Playlist` """ - return self.provider.search(**query) + return self.backend.library.search(**query).get() diff --git a/mopidy/core/playback.py b/mopidy/core/playback.py index 82a11064..efba03dd 100644 --- a/mopidy/core/playback.py +++ b/mopidy/core/playback.py @@ -79,9 +79,10 @@ class PlaybackController(object): #: Playback continues after current song. single = option_wrapper('_single', False) - def __init__(self, backend, provider): + def __init__(self, audio, backend, core): + self.audio = audio self.backend = backend - self.provider = provider + self.core = core self._state = PlaybackState.STOPPED self._shuffled = [] self._first_shuffle = True @@ -125,7 +126,7 @@ class PlaybackController(object): if self.current_cp_track is None: return None try: - return self.backend.current_playlist.cp_tracks.index( + return self.core.current_playlist.cp_tracks.index( self.current_cp_track) except ValueError: return None @@ -152,7 +153,7 @@ class PlaybackController(object): # pylint: disable = R0911 # Too many return statements - cp_tracks = self.backend.current_playlist.cp_tracks + cp_tracks = self.core.current_playlist.cp_tracks if not cp_tracks: return None @@ -204,7 +205,7 @@ class PlaybackController(object): enabled this should be a random track, all tracks should be played once before the list repeats. """ - cp_tracks = self.backend.current_playlist.cp_tracks + cp_tracks = self.core.current_playlist.cp_tracks if not cp_tracks: return None @@ -258,7 +259,7 @@ class PlaybackController(object): if self.current_playlist_position in (None, 0): return None - return self.backend.current_playlist.cp_tracks[ + return self.core.current_playlist.cp_tracks[ self.current_playlist_position - 1] @property @@ -291,15 +292,16 @@ class PlaybackController(object): @property def time_position(self): """Time position in milliseconds.""" - return self.provider.get_time_position() + return self.backend.playback.get_time_position().get() @property def volume(self): - return self.provider.get_volume() + """Volume as int in range [0..100].""" + return self.backend.playback.get_volume().get() @volume.setter def volume(self, volume): - self.provider.set_volume(volume) + self.backend.playback.set_volume(volume).get() def change_track(self, cp_track, on_error_step=1): """ @@ -337,20 +339,20 @@ class PlaybackController(object): self.stop(clear_current_track=True) if self.consume: - self.backend.current_playlist.remove(cpid=original_cp_track.cpid) + self.core.current_playlist.remove(cpid=original_cp_track.cpid) def on_current_playlist_change(self): """ Tell the playback controller that the current playlist has changed. - Used by :class:`mopidy.backends.base.CurrentPlaylistController`. + Used by :class:`mopidy.core.CurrentPlaylistController`. """ self._first_shuffle = True self._shuffled = [] - if (not self.backend.current_playlist.cp_tracks or + if (not self.core.current_playlist.cp_tracks or self.current_cp_track not in - self.backend.current_playlist.cp_tracks): + self.core.current_playlist.cp_tracks): self.stop(clear_current_track=True) def next(self): @@ -368,7 +370,7 @@ class PlaybackController(object): def pause(self): """Pause playback.""" - if self.provider.pause(): + if self.backend.playback.pause().get(): self.state = PlaybackState.PAUSED self._trigger_track_playback_paused() @@ -386,7 +388,7 @@ class PlaybackController(object): """ if cp_track is not None: - assert cp_track in self.backend.current_playlist.cp_tracks + assert cp_track in self.core.current_playlist.cp_tracks elif cp_track is None: if self.state == PlaybackState.PAUSED: return self.resume() @@ -400,7 +402,7 @@ class PlaybackController(object): if cp_track is not None: self.current_cp_track = cp_track self.state = PlaybackState.PLAYING - if not self.provider.play(cp_track.track): + if not self.backend.playback.play(cp_track.track).get(): # Track is not playable if self.random and self._shuffled: self._shuffled.remove(cp_track) @@ -426,7 +428,8 @@ class PlaybackController(object): def resume(self): """If paused, resume playing the current track.""" - if self.state == PlaybackState.PAUSED and self.provider.resume(): + if (self.state == PlaybackState.PAUSED and + self.backend.playback.resume().get()): self.state = PlaybackState.PLAYING self._trigger_track_playback_resumed() @@ -438,7 +441,7 @@ class PlaybackController(object): :type time_position: int :rtype: :class:`True` if successful, else :class:`False` """ - if not self.backend.current_playlist.tracks: + if not self.core.current_playlist.tracks: return False if self.state == PlaybackState.STOPPED: @@ -452,7 +455,7 @@ class PlaybackController(object): self.next() return True - success = self.provider.seek(time_position) + success = self.backend.playback.seek(time_position).get() if success: self._trigger_seeked(time_position) return success @@ -466,7 +469,7 @@ class PlaybackController(object): :type clear_current_track: boolean """ if self.state != PlaybackState.STOPPED: - if self.provider.stop(): + if self.backend.playback.stop().get(): self._trigger_track_playback_ended() self.state = PlaybackState.STOPPED if clear_current_track: diff --git a/mopidy/core/stored_playlists.py b/mopidy/core/stored_playlists.py index a29e34fc..6ea9b1d3 100644 --- a/mopidy/core/stored_playlists.py +++ b/mopidy/core/stored_playlists.py @@ -8,9 +8,9 @@ class StoredPlaylistsController(object): pykka_traversable = True - def __init__(self, backend, provider): + def __init__(self, backend, core): self.backend = backend - self.provider = provider + self.core = core @property def playlists(self): @@ -19,11 +19,11 @@ class StoredPlaylistsController(object): Read/write. List of :class:`mopidy.models.Playlist`. """ - return self.provider.playlists + return self.backend.stored_playlists.playlists.get() @playlists.setter def playlists(self, playlists): - self.provider.playlists = playlists + self.backend.stored_playlists.playlists = playlists def create(self, name): """ @@ -33,7 +33,7 @@ class StoredPlaylistsController(object): :type name: string :rtype: :class:`mopidy.models.Playlist` """ - return self.provider.create(name) + return self.backend.stored_playlists.create(name).get() def delete(self, playlist): """ @@ -42,7 +42,7 @@ class StoredPlaylistsController(object): :param playlist: the playlist to delete :type playlist: :class:`mopidy.models.Playlist` """ - return self.provider.delete(playlist) + return self.backend.stored_playlists.delete(playlist).get() def get(self, **criteria): """ @@ -83,14 +83,14 @@ class StoredPlaylistsController(object): :type uri: string :rtype: :class:`mopidy.models.Playlist` """ - return self.provider.lookup(uri) + return self.backend.stored_playlists.lookup(uri).get() def refresh(self): """ Refresh the stored playlists in :attr:`mopidy.backends.base.StoredPlaylistsController.playlists`. """ - return self.provider.refresh() + return self.backend.stored_playlists.refresh().get() def rename(self, playlist, new_name): """ @@ -101,7 +101,7 @@ class StoredPlaylistsController(object): :param new_name: the new name :type new_name: string """ - return self.provider.rename(playlist, new_name) + return self.backend.stored_playlists.rename(playlist, new_name).get() def save(self, playlist): """ @@ -110,4 +110,4 @@ class StoredPlaylistsController(object): :param playlist: the playlist :type playlist: :class:`mopidy.models.Playlist` """ - return self.provider.save(playlist) + return self.backend.stored_playlists.save(playlist).get() diff --git a/mopidy/frontends/mpd/dispatcher.py b/mopidy/frontends/mpd/dispatcher.py index 94ac6bf9..c9dee576 100644 --- a/mopidy/frontends/mpd/dispatcher.py +++ b/mopidy/frontends/mpd/dispatcher.py @@ -4,8 +4,7 @@ import re from pykka import ActorDeadError from pykka.registry import ActorRegistry -from mopidy import settings -from mopidy.backends.base import Backend +from mopidy import core, settings from mopidy.frontends.mpd import exceptions from mopidy.frontends.mpd.protocol import mpd_commands, request_handlers # Do not remove the following import. The protocol modules must be imported to @@ -233,16 +232,17 @@ class MpdContext(object): self.session = session self.events = set() self.subscriptions = set() - self._backend = None + self._core = None @property def backend(self): """ - The backend. An instance of :class:`mopidy.backends.base.Backend`. + The Mopidy core. An instance of :class:`mopidy.core.Core`. """ - if self._backend is None: - backend_refs = ActorRegistry.get_by_class(Backend) - assert len(backend_refs) == 1, \ - 'Expected exactly one running backend.' - self._backend = backend_refs[0].proxy() - return self._backend + # TODO: Rename property to 'core' + if self._core is None: + core_refs = ActorRegistry.get_by_class(core.Core) + assert len(core_refs) == 1, \ + 'Expected exactly one running core instance.' + self._core = core_refs[0].proxy() + return self._core diff --git a/mopidy/frontends/mpris/objects.py b/mopidy/frontends/mpris/objects.py index 93669977..c2c9f527 100644 --- a/mopidy/frontends/mpris/objects.py +++ b/mopidy/frontends/mpris/objects.py @@ -14,8 +14,7 @@ except ImportError as import_error: from pykka.registry import ActorRegistry -from mopidy import settings -from mopidy.backends.base import Backend +from mopidy import core, settings from mopidy.core import PlaybackState from mopidy.utils.process import exit_process @@ -35,7 +34,7 @@ class MprisObject(dbus.service.Object): properties = None def __init__(self): - self._backend = None + self._core = None self.properties = { ROOT_IFACE: self._get_root_iface_properties(), PLAYER_IFACE: self._get_player_iface_properties(), @@ -86,12 +85,13 @@ class MprisObject(dbus.service.Object): @property def backend(self): - if self._backend is None: - backend_refs = ActorRegistry.get_by_class(Backend) - assert len(backend_refs) == 1, \ - 'Expected exactly one running backend.' - self._backend = backend_refs[0].proxy() - return self._backend + # TODO: Rename property to 'core' + if self._core is None: + core_refs = ActorRegistry.get_by_class(core.Core) + assert len(core_refs) == 1, \ + 'Expected exactly one running core instance.' + self._core = core_refs[0].proxy() + return self._core def _get_track_id(self, cp_track): return '/com/mopidy/track/%d' % cp_track.cpid diff --git a/tests/backends/base/__init__.py b/tests/backends/base/__init__.py index 29f010e1..84eee193 100644 --- a/tests/backends/base/__init__.py +++ b/tests/backends/base/__init__.py @@ -1,7 +1,7 @@ def populate_playlist(func): def wrapper(self): for track in self.tracks: - self.backend.current_playlist.add(track) + self.core.current_playlist.add(track) return func(self) wrapper.__name__ = func.__name__ diff --git a/tests/backends/base/current_playlist.py b/tests/backends/base/current_playlist.py index a42e7eac..db4473bb 100644 --- a/tests/backends/base/current_playlist.py +++ b/tests/backends/base/current_playlist.py @@ -1,7 +1,9 @@ import mock import random -from mopidy import audio +from pykka.registry import ActorRegistry + +from mopidy import audio, core from mopidy.core import PlaybackState from mopidy.models import CpTrack, Playlist, Track @@ -12,13 +14,17 @@ class CurrentPlaylistControllerTest(object): tracks = [] def setUp(self): - self.backend = self.backend_class() - self.backend.audio = mock.Mock(spec=audio.Audio) - self.controller = self.backend.current_playlist - self.playback = self.backend.playback + self.audio = mock.Mock(spec=audio.Audio) + self.backend = self.backend_class.start(audio=self.audio).proxy() + self.core = core.Core(audio=audio, backend=self.backend) + self.controller = self.core.current_playlist + self.playback = self.core.playback assert len(self.tracks) == 3, 'Need three tracks to run tests.' + def tearDown(self): + ActorRegistry.stop_all() + def test_length(self): self.assertEqual(0, len(self.controller.cp_tracks)) self.assertEqual(0, self.controller.length) diff --git a/tests/backends/base/library.py b/tests/backends/base/library.py index f76d9d75..99dce78e 100644 --- a/tests/backends/base/library.py +++ b/tests/backends/base/library.py @@ -1,3 +1,8 @@ +import mock + +from pykka.registry import ActorRegistry + +from mopidy import core from mopidy.models import Playlist, Track, Album, Artist from tests import unittest, path_to_data_dir @@ -15,8 +20,12 @@ class LibraryControllerTest(object): Track()] def setUp(self): - self.backend = self.backend_class() - self.library = self.backend.library + self.backend = self.backend_class.start(audio=None).proxy() + self.core = core.Core(backend=self.backend) + self.library = self.core.library + + def tearDown(self): + ActorRegistry.stop_all() def test_refresh(self): self.library.refresh() diff --git a/tests/backends/base/playback.py b/tests/backends/base/playback.py index e052a907..46863f03 100644 --- a/tests/backends/base/playback.py +++ b/tests/backends/base/playback.py @@ -2,7 +2,7 @@ import mock import random import time -from mopidy import audio +from mopidy import audio, core from mopidy.core import PlaybackState from mopidy.models import Track @@ -16,10 +16,11 @@ class PlaybackControllerTest(object): tracks = [] def setUp(self): - self.backend = self.backend_class() - self.backend.audio = mock.Mock(spec=audio.Audio) - self.playback = self.backend.playback - self.current_playlist = self.backend.current_playlist + self.audio = mock.Mock(spec=audio.Audio) + self.backend = self.backend_class.start(audio=self.audio).proxy() + self.core = core.Core(backend=self.backend) + self.playback = self.core.playback + self.current_playlist = self.core.current_playlist assert len(self.tracks) >= 3, \ 'Need at least three tracks to run tests.' @@ -97,8 +98,8 @@ class PlaybackControllerTest(object): @populate_playlist def test_play_skips_to_next_track_on_failure(self): - # If provider.play() returns False, it is a failure. - self.playback.provider.play = lambda track: track != self.tracks[0] + # If backend's play() returns False, it is a failure. + self.backend.playback.play = lambda track: track != self.tracks[0] self.playback.play() self.assertNotEqual(self.playback.current_track, self.tracks[0]) self.assertEqual(self.playback.current_track, self.tracks[1]) @@ -157,8 +158,8 @@ class PlaybackControllerTest(object): @populate_playlist def test_previous_skips_to_previous_track_on_failure(self): - # If provider.play() returns False, it is a failure. - self.playback.provider.play = lambda track: track != self.tracks[1] + # If backend's play() returns False, it is a failure. + self.backend.playback.play = lambda track: track != self.tracks[1] self.playback.play(self.current_playlist.cp_tracks[2]) self.assertEqual(self.playback.current_track, self.tracks[2]) self.playback.previous() @@ -221,8 +222,8 @@ class PlaybackControllerTest(object): @populate_playlist def test_next_skips_to_next_track_on_failure(self): - # If provider.play() returns False, it is a failure. - self.playback.provider.play = lambda track: track != self.tracks[1] + # If backend's play() returns False, it is a failure. + self.backend.playback.play = lambda track: track != self.tracks[1] self.playback.play() self.assertEqual(self.playback.current_track, self.tracks[0]) self.playback.next() @@ -274,7 +275,7 @@ class PlaybackControllerTest(object): self.playback.consume = True self.playback.play() self.playback.next() - self.assertIn(self.tracks[0], self.backend.current_playlist.tracks) + self.assertIn(self.tracks[0], self.current_playlist.tracks) @populate_playlist def test_next_with_single_and_repeat(self): @@ -298,7 +299,7 @@ class PlaybackControllerTest(object): random.seed(1) self.playback.random = True self.assertEqual(self.playback.track_at_next, self.tracks[2]) - self.backend.current_playlist.append(self.tracks[:1]) + self.current_playlist.append(self.tracks[:1]) self.assertEqual(self.playback.track_at_next, self.tracks[1]) @populate_playlist @@ -357,8 +358,8 @@ class PlaybackControllerTest(object): @populate_playlist def test_end_of_track_skips_to_next_track_on_failure(self): - # If provider.play() returns False, it is a failure. - self.playback.provider.play = lambda track: track != self.tracks[1] + # If backend's play() returns False, it is a failure. + self.backend.playback.play = lambda track: track != self.tracks[1] self.playback.play() self.assertEqual(self.playback.current_track, self.tracks[0]) self.playback.on_end_of_track() @@ -411,7 +412,7 @@ class PlaybackControllerTest(object): self.playback.consume = True self.playback.play() self.playback.on_end_of_track() - self.assertNotIn(self.tracks[0], self.backend.current_playlist.tracks) + self.assertNotIn(self.tracks[0], self.current_playlist.tracks) @populate_playlist def test_end_of_track_with_random(self): @@ -427,7 +428,7 @@ class PlaybackControllerTest(object): random.seed(1) self.playback.random = True self.assertEqual(self.playback.track_at_next, self.tracks[2]) - self.backend.current_playlist.append(self.tracks[:1]) + self.current_playlist.append(self.tracks[:1]) self.assertEqual(self.playback.track_at_next, self.tracks[1]) @populate_playlist @@ -517,7 +518,7 @@ class PlaybackControllerTest(object): wrapper.called = False self.playback.on_current_playlist_change = wrapper - self.backend.current_playlist.append([Track()]) + self.current_playlist.append([Track()]) self.assert_(wrapper.called) @@ -534,13 +535,13 @@ class PlaybackControllerTest(object): def test_on_current_playlist_change_when_playing(self): self.playback.play() current_track = self.playback.current_track - self.backend.current_playlist.append([self.tracks[2]]) + self.current_playlist.append([self.tracks[2]]) self.assertEqual(self.playback.state, PlaybackState.PLAYING) self.assertEqual(self.playback.current_track, current_track) @populate_playlist def test_on_current_playlist_change_when_stopped(self): - self.backend.current_playlist.append([self.tracks[2]]) + self.current_playlist.append([self.tracks[2]]) self.assertEqual(self.playback.state, PlaybackState.STOPPED) self.assertEqual(self.playback.current_track, None) @@ -549,7 +550,7 @@ class PlaybackControllerTest(object): self.playback.play() self.playback.pause() current_track = self.playback.current_track - self.backend.current_playlist.append([self.tracks[2]]) + self.current_playlist.append([self.tracks[2]]) self.assertEqual(self.playback.state, PlaybackState.PAUSED) self.assertEqual(self.playback.current_track, current_track) @@ -640,7 +641,7 @@ class PlaybackControllerTest(object): @populate_playlist def test_seek_when_playing_updates_position(self): - length = self.backend.current_playlist.tracks[0].length + length = self.current_playlist.tracks[0].length self.playback.play() self.playback.seek(length - 1000) position = self.playback.time_position @@ -655,7 +656,7 @@ class PlaybackControllerTest(object): @populate_playlist def test_seek_when_paused_updates_position(self): - length = self.backend.current_playlist.tracks[0].length + length = self.current_playlist.tracks[0].length self.playback.play() self.playback.pause() self.playback.seek(length - 1000) @@ -730,7 +731,7 @@ class PlaybackControllerTest(object): def test_time_position_when_stopped(self): future = mock.Mock() future.get = mock.Mock(return_value=0) - self.backend.audio.get_position = mock.Mock(return_value=future) + self.audio.get_position = mock.Mock(return_value=future) self.assertEqual(self.playback.time_position, 0) @@ -738,7 +739,7 @@ class PlaybackControllerTest(object): def test_time_position_when_stopped_with_playlist(self): future = mock.Mock() future.get = mock.Mock(return_value=0) - self.backend.audio.get_position = mock.Mock(return_value=future) + self.audio.get_position = mock.Mock(return_value=future) self.assertEqual(self.playback.time_position, 0) @@ -772,9 +773,9 @@ class PlaybackControllerTest(object): def test_playlist_is_empty_after_all_tracks_are_played_with_consume(self): self.playback.consume = True self.playback.play() - for _ in range(len(self.backend.current_playlist.tracks)): + for _ in range(len(self.current_playlist.tracks)): self.playback.on_end_of_track() - self.assertEqual(len(self.backend.current_playlist.tracks), 0) + self.assertEqual(len(self.current_playlist.tracks), 0) @populate_playlist def test_play_with_random(self): diff --git a/tests/backends/base/stored_playlists.py b/tests/backends/base/stored_playlists.py index 1e575b9e..4e65c034 100644 --- a/tests/backends/base/stored_playlists.py +++ b/tests/backends/base/stored_playlists.py @@ -2,7 +2,9 @@ import os import shutil import tempfile -from mopidy import settings +import mock + +from mopidy import audio, core, settings from mopidy.models import Playlist from tests import unittest, path_to_data_dir @@ -14,8 +16,10 @@ class StoredPlaylistsControllerTest(object): settings.LOCAL_TAG_CACHE_FILE = path_to_data_dir('library_tag_cache') settings.LOCAL_MUSIC_PATH = path_to_data_dir('') - self.backend = self.backend_class() - self.stored = self.backend.stored_playlists + self.audio = mock.Mock(spec=audio.Audio) + self.backend = self.backend_class.start(audio=self.audio).proxy() + self.core = core.Core(backend=self.backend) + self.stored = self.core.stored_playlists def tearDown(self): if os.path.exists(settings.LOCAL_PLAYLIST_PATH): diff --git a/tests/backends/events_test.py b/tests/backends/events_test.py index d761676d..5408d71f 100644 --- a/tests/backends/events_test.py +++ b/tests/backends/events_test.py @@ -2,7 +2,8 @@ import mock from pykka.registry import ActorRegistry -from mopidy.backends.dummy import DummyBackend +from mopidy import audio, core +from mopidy.backends import dummy from mopidy.listeners import BackendListener from mopidy.models import Track @@ -12,42 +13,44 @@ from tests import unittest @mock.patch.object(BackendListener, 'send') class BackendEventsTest(unittest.TestCase): def setUp(self): - self.backend = DummyBackend.start().proxy() + self.audio = mock.Mock(spec=audio.Audio) + self.backend = dummy.DummyBackend.start(audio=audio).proxy() + self.core = core.Core.start(backend=self.backend).proxy() def tearDown(self): ActorRegistry.stop_all() def test_pause_sends_track_playback_paused_event(self, send): - self.backend.current_playlist.add(Track(uri='a')) - self.backend.playback.play().get() + self.core.current_playlist.add(Track(uri='a')) + self.core.playback.play().get() send.reset_mock() - self.backend.playback.pause().get() + self.core.playback.pause().get() self.assertEqual(send.call_args[0][0], 'track_playback_paused') def test_resume_sends_track_playback_resumed(self, send): - self.backend.current_playlist.add(Track(uri='a')) - self.backend.playback.play() - self.backend.playback.pause().get() + self.core.current_playlist.add(Track(uri='a')) + self.core.playback.play() + self.core.playback.pause().get() send.reset_mock() - self.backend.playback.resume().get() + self.core.playback.resume().get() self.assertEqual(send.call_args[0][0], 'track_playback_resumed') def test_play_sends_track_playback_started_event(self, send): - self.backend.current_playlist.add(Track(uri='a')) + self.core.current_playlist.add(Track(uri='a')) send.reset_mock() - self.backend.playback.play().get() + self.core.playback.play().get() self.assertEqual(send.call_args[0][0], 'track_playback_started') def test_stop_sends_track_playback_ended_event(self, send): - self.backend.current_playlist.add(Track(uri='a')) - self.backend.playback.play().get() + self.core.current_playlist.add(Track(uri='a')) + self.core.playback.play().get() send.reset_mock() - self.backend.playback.stop().get() + self.core.playback.stop().get() self.assertEqual(send.call_args_list[0][0][0], 'track_playback_ended') def test_seek_sends_seeked_event(self, send): - self.backend.current_playlist.add(Track(uri='a', length=40000)) - self.backend.playback.play().get() + self.core.current_playlist.add(Track(uri='a', length=40000)) + self.core.playback.play().get() send.reset_mock() - self.backend.playback.seek(1000).get() + self.core.playback.seek(1000).get() self.assertEqual(send.call_args[0][0], 'seeked') diff --git a/tests/backends/local/playback_test.py b/tests/backends/local/playback_test.py index c167fbcc..fe5fee32 100644 --- a/tests/backends/local/playback_test.py +++ b/tests/backends/local/playback_test.py @@ -20,10 +20,7 @@ class LocalPlaybackControllerTest(PlaybackControllerTest, unittest.TestCase): def setUp(self): settings.BACKENDS = ('mopidy.backends.local.LocalBackend',) - super(LocalPlaybackControllerTest, self).setUp() - # Two tests does not work at all when using the fake sink - #self.backend.playback.use_fake_sink() def tearDown(self): super(LocalPlaybackControllerTest, self).tearDown() @@ -32,10 +29,10 @@ class LocalPlaybackControllerTest(PlaybackControllerTest, unittest.TestCase): def add_track(self, path): uri = path_to_uri(path_to_data_dir(path)) track = Track(uri=uri, length=4464) - self.backend.current_playlist.add(track) + self.current_playlist.add(track) def test_uri_scheme(self): - self.assertIn('file', self.backend.uri_schemes) + self.assertIn('file', self.core.uri_schemes) def test_play_mp3(self): self.add_track('blank.mp3') diff --git a/tests/backends/local/stored_playlists_test.py b/tests/backends/local/stored_playlists_test.py index 56be92c4..3f3d9c58 100644 --- a/tests/backends/local/stored_playlists_test.py +++ b/tests/backends/local/stored_playlists_test.py @@ -65,8 +65,7 @@ class LocalStoredPlaylistsControllerTest(StoredPlaylistsControllerTest, self.stored.save(playlist) - self.backend = self.backend_class() - self.stored = self.backend.stored_playlists + self.backend = self.backend_class.start(audio=self.audio).proxy() self.assert_(self.stored.playlists) self.assertEqual('test', self.stored.playlists[0].name) diff --git a/tests/frontends/mpd/dispatcher_test.py b/tests/frontends/mpd/dispatcher_test.py index 9f05d7dd..0bff04e7 100644 --- a/tests/frontends/mpd/dispatcher_test.py +++ b/tests/frontends/mpd/dispatcher_test.py @@ -1,4 +1,7 @@ -from mopidy.backends.dummy import DummyBackend +from pykka.registry import ActorRegistry + +from mopidy import core +from mopidy.backends import dummy from mopidy.frontends.mpd.dispatcher import MpdDispatcher from mopidy.frontends.mpd.exceptions import MpdAckError from mopidy.frontends.mpd.protocol import request_handlers, handle_request @@ -8,11 +11,12 @@ from tests import unittest class MpdDispatcherTest(unittest.TestCase): def setUp(self): - self.backend = DummyBackend.start().proxy() + self.backend = dummy.DummyBackend.start(audio=None).proxy() + self.core = core.Core.start(backend=self.backend).proxy() self.dispatcher = MpdDispatcher() def tearDown(self): - self.backend.stop().get() + ActorRegistry.stop_all() def test_register_same_pattern_twice_fails(self): func = lambda: None diff --git a/tests/frontends/mpd/protocol/__init__.py b/tests/frontends/mpd/protocol/__init__.py index 3b8fbe33..a2dafb9b 100644 --- a/tests/frontends/mpd/protocol/__init__.py +++ b/tests/frontends/mpd/protocol/__init__.py @@ -1,7 +1,9 @@ import mock -from mopidy import settings -from mopidy.backends import dummy as backend +from pykka.registry import ActorRegistry + +from mopidy import core, settings +from mopidy.backends import dummy from mopidy.frontends import mpd from tests import unittest @@ -21,7 +23,8 @@ class MockConnection(mock.Mock): class BaseTestCase(unittest.TestCase): def setUp(self): - self.backend = backend.DummyBackend.start().proxy() + self.backend = dummy.DummyBackend.start(audio=None).proxy() + self.core = core.Core.start(backend=self.backend).proxy() self.connection = MockConnection() self.session = mpd.MpdSession(self.connection) @@ -29,7 +32,7 @@ class BaseTestCase(unittest.TestCase): self.context = self.dispatcher.context def tearDown(self): - self.backend.stop().get() + ActorRegistry.stop_all() settings.runtime.clear() def sendRequest(self, request): diff --git a/tests/frontends/mpd/protocol/current_playlist_test.py b/tests/frontends/mpd/protocol/current_playlist_test.py index 4aed5de1..63c4a42b 100644 --- a/tests/frontends/mpd/protocol/current_playlist_test.py +++ b/tests/frontends/mpd/protocol/current_playlist_test.py @@ -6,15 +6,15 @@ from tests.frontends.mpd import protocol class CurrentPlaylistHandlerTest(protocol.BaseTestCase): def test_add(self): needle = Track(uri='dummy://foo') - self.backend.library.provider.dummy_library = [ + self.backend.library.dummy_library = [ Track(), Track(), needle, Track()] - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.sendRequest(u'add "dummy://foo"') - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 6) - self.assertEqual(self.backend.current_playlist.tracks.get()[5], needle) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 6) + self.assertEqual(self.core.current_playlist.tracks.get()[5], needle) self.assertEqualResponse(u'OK') def test_add_with_uri_not_found_in_library_should_ack(self): @@ -29,17 +29,17 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): def test_addid_without_songpos(self): needle = Track(uri='dummy://foo') - self.backend.library.provider.dummy_library = [ + self.backend.library.dummy_library = [ Track(), Track(), needle, Track()] - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.sendRequest(u'addid "dummy://foo"') - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 6) - self.assertEqual(self.backend.current_playlist.tracks.get()[5], needle) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 6) + self.assertEqual(self.core.current_playlist.tracks.get()[5], needle) self.assertInResponse(u'Id: %d' % - self.backend.current_playlist.cp_tracks.get()[5][0]) + self.core.current_playlist.cp_tracks.get()[5][0]) self.assertInResponse(u'OK') def test_addid_with_empty_uri_acks(self): @@ -48,26 +48,26 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): def test_addid_with_songpos(self): needle = Track(uri='dummy://foo') - self.backend.library.provider.dummy_library = [ + self.backend.library.dummy_library = [ Track(), Track(), needle, Track()] - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.sendRequest(u'addid "dummy://foo" "3"') - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 6) - self.assertEqual(self.backend.current_playlist.tracks.get()[3], needle) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 6) + self.assertEqual(self.core.current_playlist.tracks.get()[3], needle) self.assertInResponse(u'Id: %d' % - self.backend.current_playlist.cp_tracks.get()[3][0]) + self.core.current_playlist.cp_tracks.get()[3][0]) self.assertInResponse(u'OK') def test_addid_with_songpos_out_of_bounds_should_ack(self): needle = Track(uri='dummy://foo') - self.backend.library.provider.dummy_library = [ + self.backend.library.dummy_library = [ Track(), Track(), needle, Track()] - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.sendRequest(u'addid "dummy://foo" "6"') self.assertEqualResponse(u'ACK [2@0] {addid} Bad song index') @@ -77,85 +77,85 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertEqualResponse(u'ACK [50@0] {addid} No such song') def test_clear(self): - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.sendRequest(u'clear') - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 0) - self.assertEqual(self.backend.playback.current_track.get(), None) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 0) + self.assertEqual(self.core.playback.current_track.get(), None) self.assertInResponse(u'OK') def test_delete_songpos(self): - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.sendRequest(u'delete "%d"' % - self.backend.current_playlist.cp_tracks.get()[2][0]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 4) + self.core.current_playlist.cp_tracks.get()[2][0]) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 4) self.assertInResponse(u'OK') def test_delete_songpos_out_of_bounds(self): - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.sendRequest(u'delete "5"') - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.assertEqualResponse(u'ACK [2@0] {delete} Bad song index') def test_delete_open_range(self): - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.sendRequest(u'delete "1:"') - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 1) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 1) self.assertInResponse(u'OK') def test_delete_closed_range(self): - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.sendRequest(u'delete "1:3"') - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 3) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 3) self.assertInResponse(u'OK') def test_delete_range_out_of_bounds(self): - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.sendRequest(u'delete "5:7"') - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) self.assertEqualResponse(u'ACK [2@0] {delete} Bad song index') def test_deleteid(self): - self.backend.current_playlist.append([Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 2) + self.core.current_playlist.append([Track(), Track()]) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 2) self.sendRequest(u'deleteid "1"') - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 1) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 1) self.assertInResponse(u'OK') def test_deleteid_does_not_exist(self): - self.backend.current_playlist.append([Track(), Track()]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 2) + self.core.current_playlist.append([Track(), Track()]) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 2) self.sendRequest(u'deleteid "12345"') - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 2) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 2) self.assertEqualResponse(u'ACK [50@0] {deleteid} No such song') def test_move_songpos(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) self.sendRequest(u'move "1" "0"') - tracks = self.backend.current_playlist.tracks.get() + tracks = self.core.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'b') self.assertEqual(tracks[1].name, 'a') self.assertEqual(tracks[2].name, 'c') @@ -165,13 +165,13 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_move_open_range(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) self.sendRequest(u'move "2:" "0"') - tracks = self.backend.current_playlist.tracks.get() + tracks = self.core.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'c') self.assertEqual(tracks[1].name, 'd') self.assertEqual(tracks[2].name, 'e') @@ -181,13 +181,13 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_move_closed_range(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) self.sendRequest(u'move "1:3" "0"') - tracks = self.backend.current_playlist.tracks.get() + tracks = self.core.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'b') self.assertEqual(tracks[1].name, 'c') self.assertEqual(tracks[2].name, 'a') @@ -197,13 +197,13 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_moveid(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) self.sendRequest(u'moveid "4" "2"') - tracks = self.backend.current_playlist.tracks.get() + tracks = self.core.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[1].name, 'b') self.assertEqual(tracks[2].name, 'e') @@ -230,7 +230,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertEqualResponse(u'OK') def test_playlistfind_by_filename_in_current_playlist(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(uri='file:///exists')]) self.sendRequest( u'playlistfind filename "file:///exists"') @@ -240,7 +240,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_playlistid_without_songid(self): - self.backend.current_playlist.append([Track(name='a'), Track(name='b')]) + self.core.current_playlist.append([Track(name='a'), Track(name='b')]) self.sendRequest(u'playlistid') self.assertInResponse(u'Title: a') @@ -248,7 +248,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_playlistid_with_songid(self): - self.backend.current_playlist.append([Track(name='a'), Track(name='b')]) + self.core.current_playlist.append([Track(name='a'), Track(name='b')]) self.sendRequest(u'playlistid "1"') self.assertNotInResponse(u'Title: a') @@ -258,13 +258,13 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_playlistid_with_not_existing_songid_fails(self): - self.backend.current_playlist.append([Track(name='a'), Track(name='b')]) + self.core.current_playlist.append([Track(name='a'), Track(name='b')]) self.sendRequest(u'playlistid "25"') self.assertEqualResponse(u'ACK [50@0] {playlistid} No such song') def test_playlistinfo_without_songpos_or_range(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) @@ -286,8 +286,8 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): def test_playlistinfo_with_songpos(self): # Make the track's CPID not match the playlist position - self.backend.current_playlist.cp_id = 17 - self.backend.current_playlist.append([ + self.core.current_playlist.cp_id = 17 + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) @@ -313,7 +313,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertEqual(response1, response2) def test_playlistinfo_with_open_range(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) @@ -334,7 +334,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_playlistinfo_with_closed_range(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) @@ -365,7 +365,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertEqualResponse(u'ACK [0@0] {} Not implemented') def test_plchanges(self): - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(name='a'), Track(name='b'), Track(name='c')]) self.sendRequest(u'plchanges "0"') @@ -375,7 +375,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_plchanges_with_minus_one_returns_entire_playlist(self): - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(name='a'), Track(name='b'), Track(name='c')]) self.sendRequest(u'plchanges "-1"') @@ -385,7 +385,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_plchanges_without_quotes_works(self): - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(name='a'), Track(name='b'), Track(name='c')]) self.sendRequest(u'plchanges 0') @@ -395,10 +395,10 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_plchangesposid(self): - self.backend.current_playlist.append([Track(), Track(), Track()]) + self.core.current_playlist.append([Track(), Track(), Track()]) self.sendRequest(u'plchangesposid "0"') - cp_tracks = self.backend.current_playlist.cp_tracks.get() + cp_tracks = self.core.current_playlist.cp_tracks.get() self.assertInResponse(u'cpos: 0') self.assertInResponse(u'Id: %d' % cp_tracks[0][0]) self.assertInResponse(u'cpos: 2') @@ -408,26 +408,26 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_shuffle_without_range(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - version = self.backend.current_playlist.version.get() + version = self.core.current_playlist.version.get() self.sendRequest(u'shuffle') - self.assertLess(version, self.backend.current_playlist.version.get()) + self.assertLess(version, self.core.current_playlist.version.get()) self.assertInResponse(u'OK') def test_shuffle_with_open_range(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - version = self.backend.current_playlist.version.get() + version = self.core.current_playlist.version.get() self.sendRequest(u'shuffle "4:"') - self.assertLess(version, self.backend.current_playlist.version.get()) - tracks = self.backend.current_playlist.tracks.get() + self.assertLess(version, self.core.current_playlist.version.get()) + tracks = self.core.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[1].name, 'b') self.assertEqual(tracks[2].name, 'c') @@ -435,15 +435,15 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_shuffle_with_closed_range(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - version = self.backend.current_playlist.version.get() + version = self.core.current_playlist.version.get() self.sendRequest(u'shuffle "1:3"') - self.assertLess(version, self.backend.current_playlist.version.get()) - tracks = self.backend.current_playlist.tracks.get() + self.assertLess(version, self.core.current_playlist.version.get()) + tracks = self.core.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[3].name, 'd') self.assertEqual(tracks[4].name, 'e') @@ -451,13 +451,13 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_swap(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) self.sendRequest(u'swap "1" "4"') - tracks = self.backend.current_playlist.tracks.get() + tracks = self.core.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[1].name, 'e') self.assertEqual(tracks[2].name, 'c') @@ -467,13 +467,13 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_swapid(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) self.sendRequest(u'swapid "1" "4"') - tracks = self.backend.current_playlist.tracks.get() + tracks = self.core.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[1].name, 'e') self.assertEqual(tracks[2].name, 'c') diff --git a/tests/frontends/mpd/protocol/playback_test.py b/tests/frontends/mpd/protocol/playback_test.py index 112a13ae..2380c7bc 100644 --- a/tests/frontends/mpd/protocol/playback_test.py +++ b/tests/frontends/mpd/protocol/playback_test.py @@ -13,22 +13,22 @@ STOPPED = PlaybackState.STOPPED class PlaybackOptionsHandlerTest(protocol.BaseTestCase): def test_consume_off(self): self.sendRequest(u'consume "0"') - self.assertFalse(self.backend.playback.consume.get()) + self.assertFalse(self.core.playback.consume.get()) self.assertInResponse(u'OK') def test_consume_off_without_quotes(self): self.sendRequest(u'consume 0') - self.assertFalse(self.backend.playback.consume.get()) + self.assertFalse(self.core.playback.consume.get()) self.assertInResponse(u'OK') def test_consume_on(self): self.sendRequest(u'consume "1"') - self.assertTrue(self.backend.playback.consume.get()) + self.assertTrue(self.core.playback.consume.get()) self.assertInResponse(u'OK') def test_consume_on_without_quotes(self): self.sendRequest(u'consume 1') - self.assertTrue(self.backend.playback.consume.get()) + self.assertTrue(self.core.playback.consume.get()) self.assertInResponse(u'OK') def test_crossfade(self): @@ -37,97 +37,97 @@ class PlaybackOptionsHandlerTest(protocol.BaseTestCase): def test_random_off(self): self.sendRequest(u'random "0"') - self.assertFalse(self.backend.playback.random.get()) + self.assertFalse(self.core.playback.random.get()) self.assertInResponse(u'OK') def test_random_off_without_quotes(self): self.sendRequest(u'random 0') - self.assertFalse(self.backend.playback.random.get()) + self.assertFalse(self.core.playback.random.get()) self.assertInResponse(u'OK') def test_random_on(self): self.sendRequest(u'random "1"') - self.assertTrue(self.backend.playback.random.get()) + self.assertTrue(self.core.playback.random.get()) self.assertInResponse(u'OK') def test_random_on_without_quotes(self): self.sendRequest(u'random 1') - self.assertTrue(self.backend.playback.random.get()) + self.assertTrue(self.core.playback.random.get()) self.assertInResponse(u'OK') def test_repeat_off(self): self.sendRequest(u'repeat "0"') - self.assertFalse(self.backend.playback.repeat.get()) + self.assertFalse(self.core.playback.repeat.get()) self.assertInResponse(u'OK') def test_repeat_off_without_quotes(self): self.sendRequest(u'repeat 0') - self.assertFalse(self.backend.playback.repeat.get()) + self.assertFalse(self.core.playback.repeat.get()) self.assertInResponse(u'OK') def test_repeat_on(self): self.sendRequest(u'repeat "1"') - self.assertTrue(self.backend.playback.repeat.get()) + self.assertTrue(self.core.playback.repeat.get()) self.assertInResponse(u'OK') def test_repeat_on_without_quotes(self): self.sendRequest(u'repeat 1') - self.assertTrue(self.backend.playback.repeat.get()) + self.assertTrue(self.core.playback.repeat.get()) self.assertInResponse(u'OK') def test_setvol_below_min(self): self.sendRequest(u'setvol "-10"') - self.assertEqual(0, self.backend.playback.volume.get()) + self.assertEqual(0, self.core.playback.volume.get()) self.assertInResponse(u'OK') def test_setvol_min(self): self.sendRequest(u'setvol "0"') - self.assertEqual(0, self.backend.playback.volume.get()) + self.assertEqual(0, self.core.playback.volume.get()) self.assertInResponse(u'OK') def test_setvol_middle(self): self.sendRequest(u'setvol "50"') - self.assertEqual(50, self.backend.playback.volume.get()) + self.assertEqual(50, self.core.playback.volume.get()) self.assertInResponse(u'OK') def test_setvol_max(self): self.sendRequest(u'setvol "100"') - self.assertEqual(100, self.backend.playback.volume.get()) + self.assertEqual(100, self.core.playback.volume.get()) self.assertInResponse(u'OK') def test_setvol_above_max(self): self.sendRequest(u'setvol "110"') - self.assertEqual(100, self.backend.playback.volume.get()) + self.assertEqual(100, self.core.playback.volume.get()) self.assertInResponse(u'OK') def test_setvol_plus_is_ignored(self): self.sendRequest(u'setvol "+10"') - self.assertEqual(10, self.backend.playback.volume.get()) + self.assertEqual(10, self.core.playback.volume.get()) self.assertInResponse(u'OK') def test_setvol_without_quotes(self): self.sendRequest(u'setvol 50') - self.assertEqual(50, self.backend.playback.volume.get()) + self.assertEqual(50, self.core.playback.volume.get()) self.assertInResponse(u'OK') def test_single_off(self): self.sendRequest(u'single "0"') - self.assertFalse(self.backend.playback.single.get()) + self.assertFalse(self.core.playback.single.get()) self.assertInResponse(u'OK') def test_single_off_without_quotes(self): self.sendRequest(u'single 0') - self.assertFalse(self.backend.playback.single.get()) + self.assertFalse(self.core.playback.single.get()) self.assertInResponse(u'OK') def test_single_on(self): self.sendRequest(u'single "1"') - self.assertTrue(self.backend.playback.single.get()) + self.assertTrue(self.core.playback.single.get()) self.assertInResponse(u'OK') def test_single_on_without_quotes(self): self.sendRequest(u'single 1') - self.assertTrue(self.backend.playback.single.get()) + self.assertTrue(self.core.playback.single.get()) self.assertInResponse(u'OK') def test_replay_gain_mode_off(self): @@ -166,198 +166,198 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_pause_off(self): - self.backend.current_playlist.append([Track()]) + self.core.current_playlist.append([Track()]) self.sendRequest(u'play "0"') self.sendRequest(u'pause "1"') self.sendRequest(u'pause "0"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse(u'OK') def test_pause_on(self): - self.backend.current_playlist.append([Track()]) + self.core.current_playlist.append([Track()]) self.sendRequest(u'play "0"') self.sendRequest(u'pause "1"') - self.assertEqual(PAUSED, self.backend.playback.state.get()) + self.assertEqual(PAUSED, self.core.playback.state.get()) self.assertInResponse(u'OK') def test_pause_toggle(self): - self.backend.current_playlist.append([Track()]) + self.core.current_playlist.append([Track()]) self.sendRequest(u'play "0"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse(u'OK') self.sendRequest(u'pause') - self.assertEqual(PAUSED, self.backend.playback.state.get()) + self.assertEqual(PAUSED, self.core.playback.state.get()) self.assertInResponse(u'OK') self.sendRequest(u'pause') - self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse(u'OK') def test_play_without_pos(self): - self.backend.current_playlist.append([Track()]) - self.backend.playback.state = PAUSED + self.core.current_playlist.append([Track()]) + self.core.playback.state = PAUSED self.sendRequest(u'play') - self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse(u'OK') def test_play_with_pos(self): - self.backend.current_playlist.append([Track()]) + self.core.current_playlist.append([Track()]) self.sendRequest(u'play "0"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse(u'OK') def test_play_with_pos_without_quotes(self): - self.backend.current_playlist.append([Track()]) + self.core.current_playlist.append([Track()]) self.sendRequest(u'play 0') - self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse(u'OK') def test_play_with_pos_out_of_bounds(self): - self.backend.current_playlist.append([]) + self.core.current_playlist.append([]) self.sendRequest(u'play "0"') - self.assertEqual(STOPPED, self.backend.playback.state.get()) + self.assertEqual(STOPPED, self.core.playback.state.get()) self.assertInResponse(u'ACK [2@0] {play} Bad song index') def test_play_minus_one_plays_first_in_playlist_if_no_current_track(self): - self.assertEqual(self.backend.playback.current_track.get(), None) - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEqual(self.core.playback.current_track.get(), None) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) self.sendRequest(u'play "-1"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assertEqual('a', self.backend.playback.current_track.get().uri) + self.assertEqual(PLAYING, self.core.playback.state.get()) + self.assertEqual('a', self.core.playback.current_track.get().uri) self.assertInResponse(u'OK') def test_play_minus_one_plays_current_track_if_current_track_is_set(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.assertEqual(self.backend.playback.current_track.get(), None) - self.backend.playback.play() - self.backend.playback.next() - self.backend.playback.stop() - self.assertNotEqual(self.backend.playback.current_track.get(), None) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEqual(self.core.playback.current_track.get(), None) + self.core.playback.play() + self.core.playback.next() + self.core.playback.stop() + self.assertNotEqual(self.core.playback.current_track.get(), None) self.sendRequest(u'play "-1"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assertEqual('b', self.backend.playback.current_track.get().uri) + self.assertEqual(PLAYING, self.core.playback.state.get()) + self.assertEqual('b', self.core.playback.current_track.get().uri) self.assertInResponse(u'OK') def test_play_minus_one_on_empty_playlist_does_not_ack(self): - self.backend.current_playlist.clear() + self.core.current_playlist.clear() self.sendRequest(u'play "-1"') - self.assertEqual(STOPPED, self.backend.playback.state.get()) - self.assertEqual(None, self.backend.playback.current_track.get()) + self.assertEqual(STOPPED, self.core.playback.state.get()) + self.assertEqual(None, self.core.playback.current_track.get()) self.assertInResponse(u'OK') def test_play_minus_is_ignored_if_playing(self): - self.backend.current_playlist.append([Track(length=40000)]) - self.backend.playback.seek(30000) - self.assertGreaterEqual(self.backend.playback.time_position.get(), + self.core.current_playlist.append([Track(length=40000)]) + self.core.playback.seek(30000) + self.assertGreaterEqual(self.core.playback.time_position.get(), 30000) - self.assertEquals(PLAYING, self.backend.playback.state.get()) + self.assertEquals(PLAYING, self.core.playback.state.get()) self.sendRequest(u'play "-1"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assertGreaterEqual(self.backend.playback.time_position.get(), + self.assertEqual(PLAYING, self.core.playback.state.get()) + self.assertGreaterEqual(self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_play_minus_one_resumes_if_paused(self): - self.backend.current_playlist.append([Track(length=40000)]) - self.backend.playback.seek(30000) - self.assertGreaterEqual(self.backend.playback.time_position.get(), + self.core.current_playlist.append([Track(length=40000)]) + self.core.playback.seek(30000) + self.assertGreaterEqual(self.core.playback.time_position.get(), 30000) - self.assertEquals(PLAYING, self.backend.playback.state.get()) - self.backend.playback.pause() - self.assertEquals(PAUSED, self.backend.playback.state.get()) + self.assertEquals(PLAYING, self.core.playback.state.get()) + self.core.playback.pause() + self.assertEquals(PAUSED, self.core.playback.state.get()) self.sendRequest(u'play "-1"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assertGreaterEqual(self.backend.playback.time_position.get(), + self.assertEqual(PLAYING, self.core.playback.state.get()) + self.assertGreaterEqual(self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_playid(self): - self.backend.current_playlist.append([Track()]) + self.core.current_playlist.append([Track()]) self.sendRequest(u'playid "0"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse(u'OK') def test_playid_without_quotes(self): - self.backend.current_playlist.append([Track()]) + self.core.current_playlist.append([Track()]) self.sendRequest(u'playid 0') - self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse(u'OK') def test_playid_minus_one_plays_first_in_playlist_if_no_current_track(self): - self.assertEqual(self.backend.playback.current_track.get(), None) - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEqual(self.core.playback.current_track.get(), None) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) self.sendRequest(u'playid "-1"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assertEqual('a', self.backend.playback.current_track.get().uri) + self.assertEqual(PLAYING, self.core.playback.state.get()) + self.assertEqual('a', self.core.playback.current_track.get().uri) self.assertInResponse(u'OK') def test_playid_minus_one_plays_current_track_if_current_track_is_set(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.assertEqual(self.backend.playback.current_track.get(), None) - self.backend.playback.play() - self.backend.playback.next() - self.backend.playback.stop() - self.assertNotEqual(None, self.backend.playback.current_track.get()) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEqual(self.core.playback.current_track.get(), None) + self.core.playback.play() + self.core.playback.next() + self.core.playback.stop() + self.assertNotEqual(None, self.core.playback.current_track.get()) self.sendRequest(u'playid "-1"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assertEqual('b', self.backend.playback.current_track.get().uri) + self.assertEqual(PLAYING, self.core.playback.state.get()) + self.assertEqual('b', self.core.playback.current_track.get().uri) self.assertInResponse(u'OK') def test_playid_minus_one_on_empty_playlist_does_not_ack(self): - self.backend.current_playlist.clear() + self.core.current_playlist.clear() self.sendRequest(u'playid "-1"') - self.assertEqual(STOPPED, self.backend.playback.state.get()) - self.assertEqual(None, self.backend.playback.current_track.get()) + self.assertEqual(STOPPED, self.core.playback.state.get()) + self.assertEqual(None, self.core.playback.current_track.get()) self.assertInResponse(u'OK') def test_playid_minus_is_ignored_if_playing(self): - self.backend.current_playlist.append([Track(length=40000)]) - self.backend.playback.seek(30000) - self.assertGreaterEqual(self.backend.playback.time_position.get(), + self.core.current_playlist.append([Track(length=40000)]) + self.core.playback.seek(30000) + self.assertGreaterEqual(self.core.playback.time_position.get(), 30000) - self.assertEquals(PLAYING, self.backend.playback.state.get()) + self.assertEquals(PLAYING, self.core.playback.state.get()) self.sendRequest(u'playid "-1"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assertGreaterEqual(self.backend.playback.time_position.get(), + self.assertEqual(PLAYING, self.core.playback.state.get()) + self.assertGreaterEqual(self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_playid_minus_one_resumes_if_paused(self): - self.backend.current_playlist.append([Track(length=40000)]) - self.backend.playback.seek(30000) - self.assertGreaterEqual(self.backend.playback.time_position.get(), + self.core.current_playlist.append([Track(length=40000)]) + self.core.playback.seek(30000) + self.assertGreaterEqual(self.core.playback.time_position.get(), 30000) - self.assertEquals(PLAYING, self.backend.playback.state.get()) - self.backend.playback.pause() - self.assertEquals(PAUSED, self.backend.playback.state.get()) + self.assertEquals(PLAYING, self.core.playback.state.get()) + self.core.playback.pause() + self.assertEquals(PAUSED, self.core.playback.state.get()) self.sendRequest(u'playid "-1"') - self.assertEqual(PLAYING, self.backend.playback.state.get()) - self.assertGreaterEqual(self.backend.playback.time_position.get(), + self.assertEqual(PLAYING, self.core.playback.state.get()) + self.assertGreaterEqual(self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_playid_which_does_not_exist(self): - self.backend.current_playlist.append([Track()]) + self.core.current_playlist.append([Track()]) self.sendRequest(u'playid "12345"') self.assertInResponse(u'ACK [50@0] {playid} No such song') @@ -367,49 +367,49 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_seek(self): - self.backend.current_playlist.append([Track(length=40000)]) + self.core.current_playlist.append([Track(length=40000)]) self.sendRequest(u'seek "0"') self.sendRequest(u'seek "0" "30"') - self.assertGreaterEqual(self.backend.playback.time_position, 30000) + self.assertGreaterEqual(self.core.playback.time_position, 30000) self.assertInResponse(u'OK') def test_seek_with_songpos(self): seek_track = Track(uri='2', length=40000) - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(uri='1', length=40000), seek_track]) self.sendRequest(u'seek "1" "30"') - self.assertEqual(self.backend.playback.current_track.get(), seek_track) + self.assertEqual(self.core.playback.current_track.get(), seek_track) self.assertInResponse(u'OK') def test_seek_without_quotes(self): - self.backend.current_playlist.append([Track(length=40000)]) + self.core.current_playlist.append([Track(length=40000)]) self.sendRequest(u'seek 0') self.sendRequest(u'seek 0 30') - self.assertGreaterEqual(self.backend.playback.time_position.get(), + self.assertGreaterEqual(self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_seekid(self): - self.backend.current_playlist.append([Track(length=40000)]) + self.core.current_playlist.append([Track(length=40000)]) self.sendRequest(u'seekid "0" "30"') - self.assertGreaterEqual(self.backend.playback.time_position.get(), + self.assertGreaterEqual(self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_seekid_with_cpid(self): seek_track = Track(uri='2', length=40000) - self.backend.current_playlist.append( + self.core.current_playlist.append( [Track(length=40000), seek_track]) self.sendRequest(u'seekid "1" "30"') - self.assertEqual(1, self.backend.playback.current_cpid.get()) - self.assertEqual(seek_track, self.backend.playback.current_track.get()) + self.assertEqual(1, self.core.playback.current_cpid.get()) + self.assertEqual(seek_track, self.core.playback.current_track.get()) self.assertInResponse(u'OK') def test_stop(self): self.sendRequest(u'stop') - self.assertEqual(STOPPED, self.backend.playback.state.get()) + self.assertEqual(STOPPED, self.core.playback.state.get()) self.assertInResponse(u'OK') diff --git a/tests/frontends/mpd/protocol/regression_test.py b/tests/frontends/mpd/protocol/regression_test.py index 7f214efa..90bcaf60 100644 --- a/tests/frontends/mpd/protocol/regression_test.py +++ b/tests/frontends/mpd/protocol/regression_test.py @@ -16,23 +16,23 @@ class IssueGH17RegressionTest(protocol.BaseTestCase): - Press next until you get to the unplayable track """ def test(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(uri='a'), Track(uri='b'), None, Track(uri='d'), Track(uri='e'), Track(uri='f')]) random.seed(1) # Playlist order: abcfde self.sendRequest(u'play') - self.assertEquals('a', self.backend.playback.current_track.get().uri) + self.assertEquals('a', self.core.playback.current_track.get().uri) self.sendRequest(u'random "1"') self.sendRequest(u'next') - self.assertEquals('b', self.backend.playback.current_track.get().uri) + self.assertEquals('b', self.core.playback.current_track.get().uri) self.sendRequest(u'next') # Should now be at track 'c', but playback fails and it skips ahead - self.assertEquals('f', self.backend.playback.current_track.get().uri) + self.assertEquals('f', self.core.playback.current_track.get().uri) self.sendRequest(u'next') - self.assertEquals('d', self.backend.playback.current_track.get().uri) + self.assertEquals('d', self.core.playback.current_track.get().uri) self.sendRequest(u'next') - self.assertEquals('e', self.backend.playback.current_track.get().uri) + self.assertEquals('e', self.core.playback.current_track.get().uri) class IssueGH18RegressionTest(protocol.BaseTestCase): @@ -47,7 +47,7 @@ class IssueGH18RegressionTest(protocol.BaseTestCase): """ def test(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(uri='a'), Track(uri='b'), Track(uri='c'), Track(uri='d'), Track(uri='e'), Track(uri='f')]) random.seed(1) @@ -59,11 +59,11 @@ class IssueGH18RegressionTest(protocol.BaseTestCase): self.sendRequest(u'next') self.sendRequest(u'next') - cp_track_1 = self.backend.playback.current_cp_track.get() + cp_track_1 = self.core.playback.current_cp_track.get() self.sendRequest(u'next') - cp_track_2 = self.backend.playback.current_cp_track.get() + cp_track_2 = self.core.playback.current_cp_track.get() self.sendRequest(u'next') - cp_track_3 = self.backend.playback.current_cp_track.get() + cp_track_3 = self.core.playback.current_cp_track.get() self.assertNotEqual(cp_track_1, cp_track_2) self.assertNotEqual(cp_track_2, cp_track_3) @@ -83,7 +83,7 @@ class IssueGH22RegressionTest(protocol.BaseTestCase): """ def test(self): - self.backend.current_playlist.append([ + self.core.current_playlist.append([ Track(uri='a'), Track(uri='b'), Track(uri='c'), Track(uri='d'), Track(uri='e'), Track(uri='f')]) random.seed(1) @@ -111,8 +111,8 @@ class IssueGH69RegressionTest(protocol.BaseTestCase): """ def test(self): - self.backend.stored_playlists.create('foo') - self.backend.current_playlist.append([ + self.core.stored_playlists.create('foo') + self.core.current_playlist.append([ Track(uri='a'), Track(uri='b'), Track(uri='c'), Track(uri='d'), Track(uri='e'), Track(uri='f')]) @@ -136,7 +136,7 @@ class IssueGH113RegressionTest(protocol.BaseTestCase): """ def test(self): - self.backend.stored_playlists.create( + self.core.stored_playlists.create( u'all lart spotify:track:\w\{22\} pastes') self.sendRequest(u'lsinfo "/"') diff --git a/tests/frontends/mpd/protocol/status_test.py b/tests/frontends/mpd/protocol/status_test.py index e6572eab..e2f0df9c 100644 --- a/tests/frontends/mpd/protocol/status_test.py +++ b/tests/frontends/mpd/protocol/status_test.py @@ -10,8 +10,8 @@ class StatusHandlerTest(protocol.BaseTestCase): def test_currentsong(self): track = Track() - self.backend.current_playlist.append([track]) - self.backend.playback.play() + self.core.current_playlist.append([track]) + self.core.playback.play() self.sendRequest(u'currentsong') self.assertInResponse(u'file: ') self.assertInResponse(u'Time: 0') diff --git a/tests/frontends/mpd/protocol/stored_playlists_test.py b/tests/frontends/mpd/protocol/stored_playlists_test.py index 45d6a09a..0bf9756f 100644 --- a/tests/frontends/mpd/protocol/stored_playlists_test.py +++ b/tests/frontends/mpd/protocol/stored_playlists_test.py @@ -7,7 +7,7 @@ from tests.frontends.mpd import protocol class StoredPlaylistsHandlerTest(protocol.BaseTestCase): def test_listplaylist(self): - self.backend.stored_playlists.playlists = [ + self.core.stored_playlists.playlists = [ Playlist(name='name', tracks=[Track(uri='file:///dev/urandom')])] self.sendRequest(u'listplaylist "name"') @@ -19,7 +19,7 @@ class StoredPlaylistsHandlerTest(protocol.BaseTestCase): self.assertEqualResponse(u'ACK [50@0] {listplaylist} No such playlist') def test_listplaylistinfo(self): - self.backend.stored_playlists.playlists = [ + self.core.stored_playlists.playlists = [ Playlist(name='name', tracks=[Track(uri='file:///dev/urandom')])] self.sendRequest(u'listplaylistinfo "name"') @@ -35,7 +35,7 @@ class StoredPlaylistsHandlerTest(protocol.BaseTestCase): def test_listplaylists(self): last_modified = datetime.datetime(2001, 3, 17, 13, 41, 17, 12345) - self.backend.stored_playlists.playlists = [Playlist(name='a', + self.core.stored_playlists.playlists = [Playlist(name='a', last_modified=last_modified)] self.sendRequest(u'listplaylists') @@ -45,13 +45,13 @@ class StoredPlaylistsHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_load_known_playlist_appends_to_current_playlist(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.assertEqual(len(self.backend.current_playlist.tracks.get()), 2) - self.backend.stored_playlists.playlists = [Playlist(name='A-list', + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEqual(len(self.core.current_playlist.tracks.get()), 2) + self.core.stored_playlists.playlists = [Playlist(name='A-list', tracks=[Track(uri='c'), Track(uri='d'), Track(uri='e')])] self.sendRequest(u'load "A-list"') - tracks = self.backend.current_playlist.tracks.get() + tracks = self.core.current_playlist.tracks.get() self.assertEqual(5, len(tracks)) self.assertEqual('a', tracks[0].uri) self.assertEqual('b', tracks[1].uri) @@ -62,7 +62,7 @@ class StoredPlaylistsHandlerTest(protocol.BaseTestCase): def test_load_unknown_playlist_acks(self): self.sendRequest(u'load "unknown playlist"') - self.assertEqual(0, len(self.backend.current_playlist.tracks.get())) + self.assertEqual(0, len(self.core.current_playlist.tracks.get())) self.assertEqualResponse(u'ACK [50@0] {load} No such playlist') def test_playlistadd(self): diff --git a/tests/frontends/mpd/status_test.py b/tests/frontends/mpd/status_test.py index 2397b96f..3a5bdcbe 100644 --- a/tests/frontends/mpd/status_test.py +++ b/tests/frontends/mpd/status_test.py @@ -1,3 +1,6 @@ +from pykka.registry import ActorRegistry + +from mopidy import audio, core from mopidy.backends import dummy from mopidy.core import PlaybackState from mopidy.frontends.mpd import dispatcher @@ -17,12 +20,13 @@ STOPPED = PlaybackState.STOPPED class StatusHandlerTest(unittest.TestCase): def setUp(self): - self.backend = dummy.DummyBackend.start().proxy() + self.backend = dummy.DummyBackend.start(audio=None).proxy() + self.core = core.Core.start(backend=self.backend).proxy() self.dispatcher = dispatcher.MpdDispatcher() self.context = self.dispatcher.context def tearDown(self): - self.backend.stop().get() + ActorRegistry.stop_all() def test_stats_method(self): result = status.stats(self.context) @@ -47,7 +51,7 @@ class StatusHandlerTest(unittest.TestCase): self.assertEqual(int(result['volume']), -1) def test_status_method_contains_volume(self): - self.backend.playback.volume = 17 + self.core.playback.volume = 17 result = dict(status.status(self.context)) self.assertIn('volume', result) self.assertEqual(int(result['volume']), 17) @@ -58,7 +62,7 @@ class StatusHandlerTest(unittest.TestCase): self.assertEqual(int(result['repeat']), 0) def test_status_method_contains_repeat_is_1(self): - self.backend.playback.repeat = 1 + self.core.playback.repeat = 1 result = dict(status.status(self.context)) self.assertIn('repeat', result) self.assertEqual(int(result['repeat']), 1) @@ -69,7 +73,7 @@ class StatusHandlerTest(unittest.TestCase): self.assertEqual(int(result['random']), 0) def test_status_method_contains_random_is_1(self): - self.backend.playback.random = 1 + self.core.playback.random = 1 result = dict(status.status(self.context)) self.assertIn('random', result) self.assertEqual(int(result['random']), 1) @@ -85,7 +89,7 @@ class StatusHandlerTest(unittest.TestCase): self.assertEqual(int(result['consume']), 0) def test_status_method_contains_consume_is_1(self): - self.backend.playback.consume = 1 + self.core.playback.consume = 1 result = dict(status.status(self.context)) self.assertIn('consume', result) self.assertEqual(int(result['consume']), 1) @@ -106,41 +110,41 @@ class StatusHandlerTest(unittest.TestCase): self.assertGreaterEqual(int(result['xfade']), 0) def test_status_method_contains_state_is_play(self): - self.backend.playback.state = PLAYING + self.core.playback.state = PLAYING result = dict(status.status(self.context)) self.assertIn('state', result) self.assertEqual(result['state'], 'play') def test_status_method_contains_state_is_stop(self): - self.backend.playback.state = STOPPED + self.core.playback.state = STOPPED result = dict(status.status(self.context)) self.assertIn('state', result) self.assertEqual(result['state'], 'stop') def test_status_method_contains_state_is_pause(self): - self.backend.playback.state = PLAYING - self.backend.playback.state = PAUSED + self.core.playback.state = PLAYING + self.core.playback.state = PAUSED result = dict(status.status(self.context)) self.assertIn('state', result) self.assertEqual(result['state'], 'pause') def test_status_method_when_playlist_loaded_contains_song(self): - self.backend.current_playlist.append([Track()]) - self.backend.playback.play() + self.core.current_playlist.append([Track()]) + self.core.playback.play() result = dict(status.status(self.context)) self.assertIn('song', result) self.assertGreaterEqual(int(result['song']), 0) def test_status_method_when_playlist_loaded_contains_cpid_as_songid(self): - self.backend.current_playlist.append([Track()]) - self.backend.playback.play() + self.core.current_playlist.append([Track()]) + self.core.playback.play() result = dict(status.status(self.context)) self.assertIn('songid', result) self.assertEqual(int(result['songid']), 0) def test_status_method_when_playing_contains_time_with_no_length(self): - self.backend.current_playlist.append([Track(length=None)]) - self.backend.playback.play() + self.core.current_playlist.append([Track(length=None)]) + self.core.playback.play() result = dict(status.status(self.context)) self.assertIn('time', result) (position, total) = result['time'].split(':') @@ -149,8 +153,8 @@ class StatusHandlerTest(unittest.TestCase): self.assertLessEqual(position, total) def test_status_method_when_playing_contains_time_with_length(self): - self.backend.current_playlist.append([Track(length=10000)]) - self.backend.playback.play() + self.core.current_playlist.append([Track(length=10000)]) + self.core.playback.play() result = dict(status.status(self.context)) self.assertIn('time', result) (position, total) = result['time'].split(':') @@ -159,25 +163,25 @@ class StatusHandlerTest(unittest.TestCase): self.assertLessEqual(position, total) def test_status_method_when_playing_contains_elapsed(self): - self.backend.current_playlist.append([Track(length=60000)]) - self.backend.playback.play() - self.backend.playback.pause() - self.backend.playback.seek(59123) + self.core.current_playlist.append([Track(length=60000)]) + self.core.playback.play() + self.core.playback.pause() + self.core.playback.seek(59123) result = dict(status.status(self.context)) self.assertIn('elapsed', result) self.assertEqual(result['elapsed'], '59.123') def test_status_method_when_starting_playing_contains_elapsed_zero(self): - self.backend.current_playlist.append([Track(length=10000)]) - self.backend.playback.play() - self.backend.playback.pause() + self.core.current_playlist.append([Track(length=10000)]) + self.core.playback.play() + self.core.playback.pause() result = dict(status.status(self.context)) self.assertIn('elapsed', result) self.assertEqual(result['elapsed'], '0.000') def test_status_method_when_playing_contains_bitrate(self): - self.backend.current_playlist.append([Track(bitrate=320)]) - self.backend.playback.play() + self.core.current_playlist.append([Track(bitrate=320)]) + self.core.playback.play() result = dict(status.status(self.context)) self.assertIn('bitrate', result) self.assertEqual(int(result['bitrate']), 320) diff --git a/tests/frontends/mpris/player_interface_test.py b/tests/frontends/mpris/player_interface_test.py index 89f7f1d4..236ec645 100644 --- a/tests/frontends/mpris/player_interface_test.py +++ b/tests/frontends/mpris/player_interface_test.py @@ -2,8 +2,10 @@ import sys import mock -from mopidy import OptionalDependencyError -from mopidy.backends.dummy import DummyBackend +from pykka.registry import ActorRegistry + +from mopidy import core, OptionalDependencyError +from mopidy.backends import dummy from mopidy.core import PlaybackState from mopidy.models import Album, Artist, Track @@ -23,68 +25,69 @@ STOPPED = PlaybackState.STOPPED class PlayerInterfaceTest(unittest.TestCase): def setUp(self): objects.MprisObject._connect_to_dbus = mock.Mock() - self.backend = DummyBackend.start().proxy() + self.backend = dummy.DummyBackend.start(audio=None).proxy() + self.core = core.Core.start(backend=self.backend).proxy() self.mpris = objects.MprisObject() - self.mpris._backend = self.backend + self.mpris._core = self.core def tearDown(self): - self.backend.stop() + ActorRegistry.stop_all() def test_get_playback_status_is_playing_when_playing(self): - self.backend.playback.state = PLAYING + self.core.playback.state = PLAYING result = self.mpris.Get(objects.PLAYER_IFACE, 'PlaybackStatus') self.assertEqual('Playing', result) def test_get_playback_status_is_paused_when_paused(self): - self.backend.playback.state = PAUSED + self.core.playback.state = PAUSED result = self.mpris.Get(objects.PLAYER_IFACE, 'PlaybackStatus') self.assertEqual('Paused', result) def test_get_playback_status_is_stopped_when_stopped(self): - self.backend.playback.state = STOPPED + self.core.playback.state = STOPPED result = self.mpris.Get(objects.PLAYER_IFACE, 'PlaybackStatus') self.assertEqual('Stopped', result) def test_get_loop_status_is_none_when_not_looping(self): - self.backend.playback.repeat = False - self.backend.playback.single = False + self.core.playback.repeat = False + self.core.playback.single = False result = self.mpris.Get(objects.PLAYER_IFACE, 'LoopStatus') self.assertEqual('None', result) def test_get_loop_status_is_track_when_looping_a_single_track(self): - self.backend.playback.repeat = True - self.backend.playback.single = True + self.core.playback.repeat = True + self.core.playback.single = True result = self.mpris.Get(objects.PLAYER_IFACE, 'LoopStatus') self.assertEqual('Track', result) def test_get_loop_status_is_playlist_when_looping_the_current_playlist(self): - self.backend.playback.repeat = True - self.backend.playback.single = False + self.core.playback.repeat = True + self.core.playback.single = False result = self.mpris.Get(objects.PLAYER_IFACE, 'LoopStatus') self.assertEqual('Playlist', result) def test_set_loop_status_is_ignored_if_can_control_is_false(self): self.mpris.get_CanControl = lambda *_: False - self.backend.playback.repeat = True - self.backend.playback.single = True + self.core.playback.repeat = True + self.core.playback.single = True self.mpris.Set(objects.PLAYER_IFACE, 'LoopStatus', 'None') - self.assertEquals(self.backend.playback.repeat.get(), True) - self.assertEquals(self.backend.playback.single.get(), True) + self.assertEquals(self.core.playback.repeat.get(), True) + self.assertEquals(self.core.playback.single.get(), True) def test_set_loop_status_to_none_unsets_repeat_and_single(self): self.mpris.Set(objects.PLAYER_IFACE, 'LoopStatus', 'None') - self.assertEquals(self.backend.playback.repeat.get(), False) - self.assertEquals(self.backend.playback.single.get(), False) + self.assertEquals(self.core.playback.repeat.get(), False) + self.assertEquals(self.core.playback.single.get(), False) def test_set_loop_status_to_track_sets_repeat_and_single(self): self.mpris.Set(objects.PLAYER_IFACE, 'LoopStatus', 'Track') - self.assertEquals(self.backend.playback.repeat.get(), True) - self.assertEquals(self.backend.playback.single.get(), True) + self.assertEquals(self.core.playback.repeat.get(), True) + self.assertEquals(self.core.playback.single.get(), True) def test_set_loop_status_to_playlists_sets_repeat_and_not_single(self): self.mpris.Set(objects.PLAYER_IFACE, 'LoopStatus', 'Playlist') - self.assertEquals(self.backend.playback.repeat.get(), True) - self.assertEquals(self.backend.playback.single.get(), False) + self.assertEquals(self.core.playback.repeat.get(), True) + self.assertEquals(self.core.playback.single.get(), False) def test_get_rate_is_greater_or_equal_than_minimum_rate(self): rate = self.mpris.Get(objects.PLAYER_IFACE, 'Rate') @@ -98,46 +101,46 @@ class PlayerInterfaceTest(unittest.TestCase): def test_set_rate_is_ignored_if_can_control_is_false(self): self.mpris.get_CanControl = lambda *_: False - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.Set(objects.PLAYER_IFACE, 'Rate', 0) - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.state.get(), PLAYING) def test_set_rate_to_zero_pauses_playback(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.Set(objects.PLAYER_IFACE, 'Rate', 0) - self.assertEquals(self.backend.playback.state.get(), PAUSED) + self.assertEquals(self.core.playback.state.get(), PAUSED) def test_get_shuffle_returns_true_if_random_is_active(self): - self.backend.playback.random = True + self.core.playback.random = True result = self.mpris.Get(objects.PLAYER_IFACE, 'Shuffle') self.assertTrue(result) def test_get_shuffle_returns_false_if_random_is_inactive(self): - self.backend.playback.random = False + self.core.playback.random = False result = self.mpris.Get(objects.PLAYER_IFACE, 'Shuffle') self.assertFalse(result) def test_set_shuffle_is_ignored_if_can_control_is_false(self): self.mpris.get_CanControl = lambda *_: False - self.backend.playback.random = False + self.core.playback.random = False result = self.mpris.Set(objects.PLAYER_IFACE, 'Shuffle', True) - self.assertFalse(self.backend.playback.random.get()) + self.assertFalse(self.core.playback.random.get()) def test_set_shuffle_to_true_activates_random_mode(self): - self.backend.playback.random = False - self.assertFalse(self.backend.playback.random.get()) + self.core.playback.random = False + self.assertFalse(self.core.playback.random.get()) result = self.mpris.Set(objects.PLAYER_IFACE, 'Shuffle', True) - self.assertTrue(self.backend.playback.random.get()) + self.assertTrue(self.core.playback.random.get()) def test_set_shuffle_to_false_deactivates_random_mode(self): - self.backend.playback.random = True - self.assertTrue(self.backend.playback.random.get()) + self.core.playback.random = True + self.assertTrue(self.core.playback.random.get()) result = self.mpris.Set(objects.PLAYER_IFACE, 'Shuffle', False) - self.assertFalse(self.backend.playback.random.get()) + self.assertFalse(self.core.playback.random.get()) def test_get_metadata_has_trackid_even_when_no_current_track(self): result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata') @@ -145,105 +148,105 @@ class PlayerInterfaceTest(unittest.TestCase): self.assertEquals(result['mpris:trackid'], '') def test_get_metadata_has_trackid_based_on_cpid(self): - self.backend.current_playlist.append([Track(uri='a')]) - self.backend.playback.play() - (cpid, track) = self.backend.playback.current_cp_track.get() + self.core.current_playlist.append([Track(uri='a')]) + self.core.playback.play() + (cpid, track) = self.core.playback.current_cp_track.get() result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata') self.assertIn('mpris:trackid', result.keys()) self.assertEquals(result['mpris:trackid'], '/com/mopidy/track/%d' % cpid) def test_get_metadata_has_track_length(self): - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata') self.assertIn('mpris:length', result.keys()) self.assertEquals(result['mpris:length'], 40000000) def test_get_metadata_has_track_uri(self): - self.backend.current_playlist.append([Track(uri='a')]) - self.backend.playback.play() + self.core.current_playlist.append([Track(uri='a')]) + self.core.playback.play() result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata') self.assertIn('xesam:url', result.keys()) self.assertEquals(result['xesam:url'], 'a') def test_get_metadata_has_track_title(self): - self.backend.current_playlist.append([Track(name='a')]) - self.backend.playback.play() + self.core.current_playlist.append([Track(name='a')]) + self.core.playback.play() result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata') self.assertIn('xesam:title', result.keys()) self.assertEquals(result['xesam:title'], 'a') def test_get_metadata_has_track_artists(self): - self.backend.current_playlist.append([Track(artists=[ + self.core.current_playlist.append([Track(artists=[ Artist(name='a'), Artist(name='b'), Artist(name=None)])]) - self.backend.playback.play() + self.core.playback.play() result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata') self.assertIn('xesam:artist', result.keys()) self.assertEquals(result['xesam:artist'], ['a', 'b']) def test_get_metadata_has_track_album(self): - self.backend.current_playlist.append([Track(album=Album(name='a'))]) - self.backend.playback.play() + self.core.current_playlist.append([Track(album=Album(name='a'))]) + self.core.playback.play() result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata') self.assertIn('xesam:album', result.keys()) self.assertEquals(result['xesam:album'], 'a') def test_get_metadata_has_track_album_artists(self): - self.backend.current_playlist.append([Track(album=Album(artists=[ + self.core.current_playlist.append([Track(album=Album(artists=[ Artist(name='a'), Artist(name='b'), Artist(name=None)]))]) - self.backend.playback.play() + self.core.playback.play() result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata') self.assertIn('xesam:albumArtist', result.keys()) self.assertEquals(result['xesam:albumArtist'], ['a', 'b']) def test_get_metadata_has_track_number_in_album(self): - self.backend.current_playlist.append([Track(track_no=7)]) - self.backend.playback.play() + self.core.current_playlist.append([Track(track_no=7)]) + self.core.playback.play() result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata') self.assertIn('xesam:trackNumber', result.keys()) self.assertEquals(result['xesam:trackNumber'], 7) def test_get_volume_should_return_volume_between_zero_and_one(self): - self.backend.playback.volume = None + self.core.playback.volume = None result = self.mpris.Get(objects.PLAYER_IFACE, 'Volume') self.assertEquals(result, 0) - self.backend.playback.volume = 0 + self.core.playback.volume = 0 result = self.mpris.Get(objects.PLAYER_IFACE, 'Volume') self.assertEquals(result, 0) - self.backend.playback.volume = 50 + self.core.playback.volume = 50 result = self.mpris.Get(objects.PLAYER_IFACE, 'Volume') self.assertEquals(result, 0.5) - self.backend.playback.volume = 100 + self.core.playback.volume = 100 result = self.mpris.Get(objects.PLAYER_IFACE, 'Volume') self.assertEquals(result, 1) def test_set_volume_is_ignored_if_can_control_is_false(self): self.mpris.get_CanControl = lambda *_: False - self.backend.playback.volume = 0 + self.core.playback.volume = 0 self.mpris.Set(objects.PLAYER_IFACE, 'Volume', 1.0) - self.assertEquals(self.backend.playback.volume.get(), 0) + self.assertEquals(self.core.playback.volume.get(), 0) def test_set_volume_to_one_should_set_mixer_volume_to_100(self): self.mpris.Set(objects.PLAYER_IFACE, 'Volume', 1.0) - self.assertEquals(self.backend.playback.volume.get(), 100) + self.assertEquals(self.core.playback.volume.get(), 100) def test_set_volume_to_anything_above_one_should_set_mixer_volume_to_100(self): self.mpris.Set(objects.PLAYER_IFACE, 'Volume', 2.0) - self.assertEquals(self.backend.playback.volume.get(), 100) + self.assertEquals(self.core.playback.volume.get(), 100) def test_set_volume_to_anything_not_a_number_does_not_change_volume(self): - self.backend.playback.volume = 10 + self.core.playback.volume = 10 self.mpris.Set(objects.PLAYER_IFACE, 'Volume', None) - self.assertEquals(self.backend.playback.volume.get(), 10) + self.assertEquals(self.core.playback.volume.get(), 10) def test_get_position_returns_time_position_in_microseconds(self): - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() - self.backend.playback.seek(10000) + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() + self.core.playback.seek(10000) result_in_microseconds = self.mpris.Get(objects.PLAYER_IFACE, 'Position') result_in_milliseconds = result_in_microseconds // 1000 self.assertGreaterEqual(result_in_milliseconds, 10000) @@ -263,61 +266,61 @@ class PlayerInterfaceTest(unittest.TestCase): def test_can_go_next_is_true_if_can_control_and_other_next_track(self): self.mpris.get_CanControl = lambda *_: True - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoNext') self.assertTrue(result) def test_can_go_next_is_false_if_next_track_is_the_same(self): self.mpris.get_CanControl = lambda *_: True - self.backend.current_playlist.append([Track(uri='a')]) - self.backend.playback.repeat = True - self.backend.playback.play() + self.core.current_playlist.append([Track(uri='a')]) + self.core.playback.repeat = True + self.core.playback.play() result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoNext') self.assertFalse(result) def test_can_go_next_is_false_if_can_control_is_false(self): self.mpris.get_CanControl = lambda *_: False - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoNext') self.assertFalse(result) def test_can_go_previous_is_true_if_can_control_and_other_previous_track(self): self.mpris.get_CanControl = lambda *_: True - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.next() + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.next() result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoPrevious') self.assertTrue(result) def test_can_go_previous_is_false_if_previous_track_is_the_same(self): self.mpris.get_CanControl = lambda *_: True - self.backend.current_playlist.append([Track(uri='a')]) - self.backend.playback.repeat = True - self.backend.playback.play() + self.core.current_playlist.append([Track(uri='a')]) + self.core.playback.repeat = True + self.core.playback.play() result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoPrevious') self.assertFalse(result) def test_can_go_previous_is_false_if_can_control_is_false(self): self.mpris.get_CanControl = lambda *_: False - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.next() + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.next() result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoPrevious') self.assertFalse(result) def test_can_play_is_true_if_can_control_and_current_track(self): self.mpris.get_CanControl = lambda *_: True - self.backend.current_playlist.append([Track(uri='a')]) - self.backend.playback.play() - self.assertTrue(self.backend.playback.current_track.get()) + self.core.current_playlist.append([Track(uri='a')]) + self.core.playback.play() + self.assertTrue(self.core.playback.current_track.get()) result = self.mpris.Get(objects.PLAYER_IFACE, 'CanPlay') self.assertTrue(result) def test_can_play_is_false_if_no_current_track(self): self.mpris.get_CanControl = lambda *_: True - self.assertFalse(self.backend.playback.current_track.get()) + self.assertFalse(self.core.playback.current_track.get()) result = self.mpris.Get(objects.PLAYER_IFACE, 'CanPlay') self.assertFalse(result) @@ -352,223 +355,223 @@ class PlayerInterfaceTest(unittest.TestCase): def test_next_is_ignored_if_can_go_next_is_false(self): self.mpris.get_CanGoNext = lambda *_: False - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.current_track.get().uri, 'a') self.mpris.Next() - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.current_track.get().uri, 'a') def test_next_when_playing_should_skip_to_next_track_and_keep_playing(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.Next() - self.assertEquals(self.backend.playback.current_track.get().uri, 'b') - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'b') + self.assertEquals(self.core.playback.state.get(), PLAYING) def test_next_when_at_end_of_list_should_stop_playback(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.next() - self.assertEquals(self.backend.playback.current_track.get().uri, 'b') - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.next() + self.assertEquals(self.core.playback.current_track.get().uri, 'b') + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.Next() - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.assertEquals(self.core.playback.state.get(), STOPPED) def test_next_when_paused_should_skip_to_next_track_and_stay_paused(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.pause() - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') - self.assertEquals(self.backend.playback.state.get(), PAUSED) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.pause() + self.assertEquals(self.core.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PAUSED) self.mpris.Next() - self.assertEquals(self.backend.playback.current_track.get().uri, 'b') - self.assertEquals(self.backend.playback.state.get(), PAUSED) + self.assertEquals(self.core.playback.current_track.get().uri, 'b') + self.assertEquals(self.core.playback.state.get(), PAUSED) def test_next_when_stopped_should_skip_to_next_track_and_stay_stopped(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.stop() - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.stop() + self.assertEquals(self.core.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), STOPPED) self.mpris.Next() - self.assertEquals(self.backend.playback.current_track.get().uri, 'b') - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.assertEquals(self.core.playback.current_track.get().uri, 'b') + self.assertEquals(self.core.playback.state.get(), STOPPED) def test_previous_is_ignored_if_can_go_previous_is_false(self): self.mpris.get_CanGoPrevious = lambda *_: False - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.next() - self.assertEquals(self.backend.playback.current_track.get().uri, 'b') + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.next() + self.assertEquals(self.core.playback.current_track.get().uri, 'b') self.mpris.Previous() - self.assertEquals(self.backend.playback.current_track.get().uri, 'b') + self.assertEquals(self.core.playback.current_track.get().uri, 'b') def test_previous_when_playing_should_skip_to_prev_track_and_keep_playing(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.next() - self.assertEquals(self.backend.playback.current_track.get().uri, 'b') - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.next() + self.assertEquals(self.core.playback.current_track.get().uri, 'b') + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.Previous() - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PLAYING) def test_previous_when_at_start_of_list_should_stop_playback(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.Previous() - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.assertEquals(self.core.playback.state.get(), STOPPED) def test_previous_when_paused_should_skip_to_previous_track_and_stay_paused(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.next() - self.backend.playback.pause() - self.assertEquals(self.backend.playback.current_track.get().uri, 'b') - self.assertEquals(self.backend.playback.state.get(), PAUSED) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.next() + self.core.playback.pause() + self.assertEquals(self.core.playback.current_track.get().uri, 'b') + self.assertEquals(self.core.playback.state.get(), PAUSED) self.mpris.Previous() - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') - self.assertEquals(self.backend.playback.state.get(), PAUSED) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PAUSED) def test_previous_when_stopped_should_skip_to_previous_track_and_stay_stopped(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.next() - self.backend.playback.stop() - self.assertEquals(self.backend.playback.current_track.get().uri, 'b') - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.next() + self.core.playback.stop() + self.assertEquals(self.core.playback.current_track.get().uri, 'b') + self.assertEquals(self.core.playback.state.get(), STOPPED) self.mpris.Previous() - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), STOPPED) def test_pause_is_ignored_if_can_pause_is_false(self): self.mpris.get_CanPause = lambda *_: False - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.Pause() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.state.get(), PLAYING) def test_pause_when_playing_should_pause_playback(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.Pause() - self.assertEquals(self.backend.playback.state.get(), PAUSED) + self.assertEquals(self.core.playback.state.get(), PAUSED) def test_pause_when_paused_has_no_effect(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.pause() - self.assertEquals(self.backend.playback.state.get(), PAUSED) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.pause() + self.assertEquals(self.core.playback.state.get(), PAUSED) self.mpris.Pause() - self.assertEquals(self.backend.playback.state.get(), PAUSED) + self.assertEquals(self.core.playback.state.get(), PAUSED) def test_playpause_is_ignored_if_can_pause_is_false(self): self.mpris.get_CanPause = lambda *_: False - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.PlayPause() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.state.get(), PLAYING) def test_playpause_when_playing_should_pause_playback(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.PlayPause() - self.assertEquals(self.backend.playback.state.get(), PAUSED) + self.assertEquals(self.core.playback.state.get(), PAUSED) def test_playpause_when_paused_should_resume_playback(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.pause() + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.pause() - self.assertEquals(self.backend.playback.state.get(), PAUSED) - at_pause = self.backend.playback.time_position.get() + self.assertEquals(self.core.playback.state.get(), PAUSED) + at_pause = self.core.playback.time_position.get() self.assertGreaterEqual(at_pause, 0) self.mpris.PlayPause() - self.assertEquals(self.backend.playback.state.get(), PLAYING) - after_pause = self.backend.playback.time_position.get() + self.assertEquals(self.core.playback.state.get(), PLAYING) + after_pause = self.core.playback.time_position.get() self.assertGreaterEqual(after_pause, at_pause) def test_playpause_when_stopped_should_start_playback(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEquals(self.core.playback.state.get(), STOPPED) self.mpris.PlayPause() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.state.get(), PLAYING) def test_stop_is_ignored_if_can_control_is_false(self): self.mpris.get_CanControl = lambda *_: False - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.Stop() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.state.get(), PLAYING) def test_stop_when_playing_should_stop_playback(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.state.get(), PLAYING) self.mpris.Stop() - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.assertEquals(self.core.playback.state.get(), STOPPED) def test_stop_when_paused_should_stop_playback(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.pause() - self.assertEquals(self.backend.playback.state.get(), PAUSED) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.pause() + self.assertEquals(self.core.playback.state.get(), PAUSED) self.mpris.Stop() - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.assertEquals(self.core.playback.state.get(), STOPPED) def test_play_is_ignored_if_can_play_is_false(self): self.mpris.get_CanPlay = lambda *_: False - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEquals(self.core.playback.state.get(), STOPPED) self.mpris.Play() - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.assertEquals(self.core.playback.state.get(), STOPPED) def test_play_when_stopped_starts_playback(self): - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEquals(self.core.playback.state.get(), STOPPED) self.mpris.Play() - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.state.get(), PLAYING) def test_play_after_pause_resumes_from_same_position(self): - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() - before_pause = self.backend.playback.time_position.get() + before_pause = self.core.playback.time_position.get() self.assertGreaterEqual(before_pause, 0) self.mpris.Pause() - self.assertEquals(self.backend.playback.state.get(), PAUSED) - at_pause = self.backend.playback.time_position.get() + self.assertEquals(self.core.playback.state.get(), PAUSED) + at_pause = self.core.playback.time_position.get() self.assertGreaterEqual(at_pause, before_pause) self.mpris.Play() - self.assertEquals(self.backend.playback.state.get(), PLAYING) - after_pause = self.backend.playback.time_position.get() + self.assertEquals(self.core.playback.state.get(), PLAYING) + after_pause = self.core.playback.time_position.get() self.assertGreaterEqual(after_pause, at_pause) def test_play_when_there_is_no_track_has_no_effect(self): - self.backend.current_playlist.clear() - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.core.current_playlist.clear() + self.assertEquals(self.core.playback.state.get(), STOPPED) self.mpris.Play() - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.assertEquals(self.core.playback.state.get(), STOPPED) def test_seek_is_ignored_if_can_seek_is_false(self): self.mpris.get_CanSeek = lambda *_: False - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() - before_seek = self.backend.playback.time_position.get() + before_seek = self.core.playback.time_position.get() self.assertGreaterEqual(before_seek, 0) milliseconds_to_seek = 10000 @@ -576,15 +579,15 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.Seek(microseconds_to_seek) - after_seek = self.backend.playback.time_position.get() + after_seek = self.core.playback.time_position.get() self.assertLessEqual(before_seek, after_seek) self.assertLess(after_seek, before_seek + milliseconds_to_seek) def test_seek_seeks_given_microseconds_forward_in_the_current_track(self): - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() - before_seek = self.backend.playback.time_position.get() + before_seek = self.core.playback.time_position.get() self.assertGreaterEqual(before_seek, 0) milliseconds_to_seek = 10000 @@ -592,17 +595,17 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.Seek(microseconds_to_seek) - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.state.get(), PLAYING) - after_seek = self.backend.playback.time_position.get() + after_seek = self.core.playback.time_position.get() self.assertGreaterEqual(after_seek, before_seek + milliseconds_to_seek) def test_seek_seeks_given_microseconds_backward_if_negative(self): - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() - self.backend.playback.seek(20000) + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() + self.core.playback.seek(20000) - before_seek = self.backend.playback.time_position.get() + before_seek = self.core.playback.time_position.get() self.assertGreaterEqual(before_seek, 20000) milliseconds_to_seek = -10000 @@ -610,18 +613,18 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.Seek(microseconds_to_seek) - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.state.get(), PLAYING) - after_seek = self.backend.playback.time_position.get() + after_seek = self.core.playback.time_position.get() self.assertGreaterEqual(after_seek, before_seek + milliseconds_to_seek) self.assertLess(after_seek, before_seek) def test_seek_seeks_to_start_of_track_if_new_position_is_negative(self): - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() - self.backend.playback.seek(20000) + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() + self.core.playback.seek(20000) - before_seek = self.backend.playback.time_position.get() + before_seek = self.core.playback.time_position.get() self.assertGreaterEqual(before_seek, 20000) milliseconds_to_seek = -30000 @@ -629,42 +632,42 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.Seek(microseconds_to_seek) - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.state.get(), PLAYING) - after_seek = self.backend.playback.time_position.get() + after_seek = self.core.playback.time_position.get() self.assertGreaterEqual(after_seek, before_seek + milliseconds_to_seek) self.assertLess(after_seek, before_seek) self.assertGreaterEqual(after_seek, 0) def test_seek_skips_to_next_track_if_new_position_larger_than_track_length(self): - self.backend.current_playlist.append([Track(uri='a', length=40000), + self.core.current_playlist.append([Track(uri='a', length=40000), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.seek(20000) + self.core.playback.play() + self.core.playback.seek(20000) - before_seek = self.backend.playback.time_position.get() + before_seek = self.core.playback.time_position.get() self.assertGreaterEqual(before_seek, 20000) - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') milliseconds_to_seek = 50000 microseconds_to_seek = milliseconds_to_seek * 1000 self.mpris.Seek(microseconds_to_seek) - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, 'b') + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'b') - after_seek = self.backend.playback.time_position.get() + after_seek = self.core.playback.time_position.get() self.assertGreaterEqual(after_seek, 0) self.assertLess(after_seek, before_seek) def test_set_position_is_ignored_if_can_seek_is_false(self): self.mpris.get_CanSeek = lambda *_: False - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() - before_set_position = self.backend.playback.time_position.get() + before_set_position = self.core.playback.time_position.get() self.assertLessEqual(before_set_position, 5000) track_id = 'a' @@ -674,17 +677,17 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.SetPosition(track_id, position_to_set_in_microseconds) - after_set_position = self.backend.playback.time_position.get() + after_set_position = self.core.playback.time_position.get() self.assertLessEqual(before_set_position, after_set_position) self.assertLess(after_set_position, position_to_set_in_milliseconds) def test_set_position_sets_the_current_track_position_in_microsecs(self): - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() - before_set_position = self.backend.playback.time_position.get() + before_set_position = self.core.playback.time_position.get() self.assertLessEqual(before_set_position, 5000) - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.state.get(), PLAYING) track_id = '/com/mopidy/track/0' @@ -693,21 +696,21 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.SetPosition(track_id, position_to_set_in_microseconds) - self.assertEquals(self.backend.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.state.get(), PLAYING) - after_set_position = self.backend.playback.time_position.get() + after_set_position = self.core.playback.time_position.get() self.assertGreaterEqual(after_set_position, position_to_set_in_milliseconds) def test_set_position_does_nothing_if_the_position_is_negative(self): - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() - self.backend.playback.seek(20000) + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() + self.core.playback.seek(20000) - before_set_position = self.backend.playback.time_position.get() + before_set_position = self.core.playback.time_position.get() self.assertGreaterEqual(before_set_position, 20000) self.assertLessEqual(before_set_position, 25000) - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') track_id = '/com/mopidy/track/0' @@ -716,21 +719,21 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.SetPosition(track_id, position_to_set_in_microseconds) - after_set_position = self.backend.playback.time_position.get() + after_set_position = self.core.playback.time_position.get() self.assertGreaterEqual(after_set_position, before_set_position) - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') def test_set_position_does_nothing_if_position_is_larger_than_track_length(self): - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() - self.backend.playback.seek(20000) + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() + self.core.playback.seek(20000) - before_set_position = self.backend.playback.time_position.get() + before_set_position = self.core.playback.time_position.get() self.assertGreaterEqual(before_set_position, 20000) self.assertLessEqual(before_set_position, 25000) - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') track_id = 'a' @@ -739,21 +742,21 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.SetPosition(track_id, position_to_set_in_microseconds) - after_set_position = self.backend.playback.time_position.get() + after_set_position = self.core.playback.time_position.get() self.assertGreaterEqual(after_set_position, before_set_position) - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') def test_set_position_does_nothing_if_track_id_does_not_match_current_track(self): - self.backend.current_playlist.append([Track(uri='a', length=40000)]) - self.backend.playback.play() - self.backend.playback.seek(20000) + self.core.current_playlist.append([Track(uri='a', length=40000)]) + self.core.playback.play() + self.core.playback.seek(20000) - before_set_position = self.backend.playback.time_position.get() + before_set_position = self.core.playback.time_position.get() self.assertGreaterEqual(before_set_position, 20000) self.assertLessEqual(before_set_position, 25000) - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') track_id = 'b' @@ -762,74 +765,74 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.SetPosition(track_id, position_to_set_in_microseconds) - after_set_position = self.backend.playback.time_position.get() + after_set_position = self.core.playback.time_position.get() self.assertGreaterEqual(after_set_position, before_set_position) - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') def test_open_uri_is_ignored_if_can_play_is_false(self): self.mpris.get_CanPlay = lambda *_: False - self.backend.library.provider.dummy_library = [ + self.backend.library.dummy_library = [ Track(uri='dummy:/test/uri')] self.mpris.OpenUri('dummy:/test/uri') - self.assertEquals(len(self.backend.current_playlist.tracks.get()), 0) + self.assertEquals(len(self.core.current_playlist.tracks.get()), 0) def test_open_uri_ignores_uris_with_unknown_uri_scheme(self): - self.assertListEqual(self.backend.uri_schemes.get(), ['dummy']) + self.assertListEqual(self.core.uri_schemes.get(), ['dummy']) self.mpris.get_CanPlay = lambda *_: True - self.backend.library.provider.dummy_library = [ + self.backend.library.dummy_library = [ Track(uri='notdummy:/test/uri')] self.mpris.OpenUri('notdummy:/test/uri') - self.assertEquals(len(self.backend.current_playlist.tracks.get()), 0) + self.assertEquals(len(self.core.current_playlist.tracks.get()), 0) def test_open_uri_adds_uri_to_current_playlist(self): self.mpris.get_CanPlay = lambda *_: True - self.backend.library.provider.dummy_library = [ + self.backend.library.dummy_library = [ Track(uri='dummy:/test/uri')] self.mpris.OpenUri('dummy:/test/uri') - self.assertEquals(self.backend.current_playlist.tracks.get()[0].uri, + self.assertEquals(self.core.current_playlist.tracks.get()[0].uri, 'dummy:/test/uri') def test_open_uri_starts_playback_of_new_track_if_stopped(self): self.mpris.get_CanPlay = lambda *_: True - self.backend.library.provider.dummy_library = [ + self.backend.library.dummy_library = [ Track(uri='dummy:/test/uri')] - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.assertEquals(self.backend.playback.state.get(), STOPPED) + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEquals(self.core.playback.state.get(), STOPPED) self.mpris.OpenUri('dummy:/test/uri') - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'dummy:/test/uri') def test_open_uri_starts_playback_of_new_track_if_paused(self): self.mpris.get_CanPlay = lambda *_: True - self.backend.library.provider.dummy_library = [ + self.backend.library.dummy_library = [ Track(uri='dummy:/test/uri')] - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.backend.playback.pause() - self.assertEquals(self.backend.playback.state.get(), PAUSED) - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.core.playback.pause() + self.assertEquals(self.core.playback.state.get(), PAUSED) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') self.mpris.OpenUri('dummy:/test/uri') - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'dummy:/test/uri') def test_open_uri_starts_playback_of_new_track_if_playing(self): self.mpris.get_CanPlay = lambda *_: True - self.backend.library.provider.dummy_library = [ + self.backend.library.dummy_library = [ Track(uri='dummy:/test/uri')] - self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.backend.playback.play() - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, 'a') + self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.core.playback.play() + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'a') self.mpris.OpenUri('dummy:/test/uri') - self.assertEquals(self.backend.playback.state.get(), PLAYING) - self.assertEquals(self.backend.playback.current_track.get().uri, + self.assertEquals(self.core.playback.state.get(), PLAYING) + self.assertEquals(self.core.playback.current_track.get().uri, 'dummy:/test/uri') diff --git a/tests/frontends/mpris/root_interface_test.py b/tests/frontends/mpris/root_interface_test.py index 1e54fc15..b84b70c3 100644 --- a/tests/frontends/mpris/root_interface_test.py +++ b/tests/frontends/mpris/root_interface_test.py @@ -2,8 +2,10 @@ import sys import mock -from mopidy import OptionalDependencyError, settings -from mopidy.backends.dummy import DummyBackend +from pykka.registry import ActorRegistry + +from mopidy import core, settings, OptionalDependencyError +from mopidy.backends import dummy try: from mopidy.frontends.mpris import objects @@ -18,11 +20,12 @@ class RootInterfaceTest(unittest.TestCase): def setUp(self): objects.exit_process = mock.Mock() objects.MprisObject._connect_to_dbus = mock.Mock() - self.backend = DummyBackend.start().proxy() + self.backend = dummy.DummyBackend.start(audio=None).proxy() + self.core = core.Core.start(backend=self.backend).proxy() self.mpris = objects.MprisObject() def tearDown(self): - self.backend.stop() + ActorRegistry.stop_all() def test_constructor_connects_to_dbus(self): self.assert_(self.mpris._connect_to_dbus.called)