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

Add PlaybackState enum

Browse Source
This commit is contained in:
Stein Magnus Jodal 2012-09-14 00:28:14 +02:00
parent 8802ea56f1
commit 2ba05f9405
14 changed files with 136 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
docs/api/core.rst
View File

@ -16,6 +16,9 @@ Playback controller
Manages playback, with actions like play, pause, stop, next, previous,
seek, and volume control.
.. autoclass:: mopidy.core.PlaybackState
:members:
.. autoclass:: mopidy.core.PlaybackController
:members:

3
mopidy/backends/spotify/playback.py
View File

@ -3,6 +3,7 @@ import logging
from spotify import Link, SpotifyError
from mopidy.backends.base import BasePlaybackProvider
from mopidy.core import PlaybackState
logger = logging.getLogger('mopidy.backends.spotify.playback')
@ -11,7 +12,7 @@ class SpotifyPlaybackProvider(BasePlaybackProvider):
return self.backend.audio.pause_playback()
def play(self, track):
if self.backend.playback.state == self.backend.playback.PLAYING:
if self.backend.playback.state == PlaybackState.PLAYING:
self.backend.spotify.session.play(0)
if track.uri is None:
return False

2
mopidy/core/__init__.py
View File

@ -1,4 +1,4 @@
from .current_playlist import CurrentPlaylistController
from .library import LibraryController
from .playback import PlaybackController
from .playback import PlaybackController, PlaybackState
from .stored_playlists import StoredPlaylistsController

67
mopidy/core/playback.py
View File

@ -20,6 +20,22 @@ def option_wrapper(name, default):
return property(get_option, set_option)
class PlaybackState(object):
"""
Enum of playback states.
"""
#: Constant representing the paused state.
PAUSED = u'paused'
#: Constant representing the playing state.
PLAYING = u'playing'
#: Constant representing the stopped state.
STOPPED = u'stopped'
class PlaybackController(object):
"""
:param backend: the backend
@ -33,15 +49,6 @@ class PlaybackController(object):
pykka_traversable = True
#: Constant representing the paused state.
PAUSED = u'paused'
#: Constant representing the playing state.
PLAYING = u'playing'
#: Constant representing the stopped state.
STOPPED = u'stopped'
#: :class:`True`
#: Tracks are removed from the playlist when they have been played.
#: :class:`False`
@ -77,7 +84,7 @@ class PlaybackController(object):
def __init__(self, backend, provider):
self.backend = backend
self.provider = provider
self._state = self.STOPPED
self._state = PlaybackState.STOPPED
self._shuffled = []
self._first_shuffle = True
self.play_time_accumulated = 0
@ -287,24 +294,26 @@ class PlaybackController(object):
# FIXME play_time stuff assumes backend does not have a better way of
# handeling this stuff :/
if (old_state in (self.PLAYING, self.STOPPED)
and new_state == self.PLAYING):
if (old_state in (PlaybackState.PLAYING, PlaybackState.STOPPED)
and new_state == PlaybackState.PLAYING):
self._play_time_start()
elif old_state == self.PLAYING and new_state == self.PAUSED:
elif (old_state == PlaybackState.PLAYING
and new_state == PlaybackState.PAUSED):
self._play_time_pause()
elif old_state == self.PAUSED and new_state == self.PLAYING:
elif (old_state == PlaybackState.PAUSED
and new_state == PlaybackState.PLAYING):
self._play_time_resume()
@property
def time_position(self):
"""Time position in milliseconds."""
if self.state == self.PLAYING:
if self.state == PlaybackState.PLAYING:
time_since_started = (self._current_wall_time -
self.play_time_started)
return self.play_time_accumulated + time_since_started
elif self.state == self.PAUSED:
elif self.state == PlaybackState.PAUSED:
return self.play_time_accumulated
elif self.state == self.STOPPED:
elif self.state == PlaybackState.STOPPED:
return 0
def _play_time_start(self):
@ -345,16 +354,16 @@ class PlaybackController(object):
old_state = self.state
self.stop()
self.current_cp_track = cp_track
if old_state == self.PLAYING:
if old_state == PlaybackState.PLAYING:
self.play(on_error_step=on_error_step)
elif old_state == self.PAUSED:
elif old_state == PlaybackState.PAUSED:
self.pause()
def on_end_of_track(self):
"""
Tell the playback controller that end of track is reached.
"""
if self.state == self.STOPPED:
if self.state == PlaybackState.STOPPED:
return
original_cp_track = self.current_cp_track
@ -398,7 +407,7 @@ class PlaybackController(object):
def pause(self):
"""Pause playback."""
if self.provider.pause():
self.state = self.PAUSED
self.state = PlaybackState.PAUSED
self._trigger_track_playback_paused()
def play(self, cp_track=None, on_error_step=1):
@ -417,7 +426,7 @@ class PlaybackController(object):
if cp_track is not None:
assert cp_track in self.backend.current_playlist.cp_tracks
elif cp_track is None:
if self.state == self.PAUSED:
if self.state == PlaybackState.PAUSED:
return self.resume()
elif self.current_cp_track is not None:
cp_track = self.current_cp_track
@ -428,7 +437,7 @@ class PlaybackController(object):
if cp_track is not None:
self.current_cp_track = cp_track
self.state = self.PLAYING
self.state = PlaybackState.PLAYING
if not self.provider.play(cp_track.track):
# Track is not playable
if self.random and self._shuffled:
@ -455,8 +464,8 @@ class PlaybackController(object):
def resume(self):
"""If paused, resume playing the current track."""
if self.state == self.PAUSED and self.provider.resume():
self.state = self.PLAYING
if self.state == PlaybackState.PAUSED and self.provider.resume():
self.state = PlaybackState.PLAYING
self._trigger_track_playback_resumed()
def seek(self, time_position):
@ -470,9 +479,9 @@ class PlaybackController(object):
if not self.backend.current_playlist.tracks:
return False
if self.state == self.STOPPED:
if self.state == PlaybackState.STOPPED:
self.play()
elif self.state == self.PAUSED:
elif self.state == PlaybackState.PAUSED:
self.resume()
if time_position < 0:
@ -497,10 +506,10 @@ class PlaybackController(object):
stopping
:type clear_current_track: boolean
"""
if self.state != self.STOPPED:
if self.state != PlaybackState.STOPPED:
if self.provider.stop():
self._trigger_track_playback_ended()
self.state = self.STOPPED
self.state = PlaybackState.STOPPED
if clear_current_track:
self.current_cp_track = None

14
mopidy/frontends/mpd/protocol/playback.py
View File

@ -1,4 +1,4 @@
from mopidy import core
from mopidy.core import PlaybackState
from mopidy.frontends.mpd.protocol import handle_request
from mopidy.frontends.mpd.exceptions import (MpdArgError, MpdNoExistError,
MpdNotImplemented)
@ -104,11 +104,9 @@ def pause(context, state=None):
- Calls ``pause`` without any arguments to toogle pause.
"""
if state is None:
if (context.backend.playback.state.get() ==
core.PlaybackController.PLAYING):
if (context.backend.playback.state.get() == PlaybackState.PLAYING):
context.backend.playback.pause()
elif (context.backend.playback.state.get() ==
core.PlaybackController.PAUSED):
elif (context.backend.playback.state.get() == PlaybackState.PAUSED):
context.backend.playback.resume()
elif int(state):
context.backend.playback.pause()
@ -185,11 +183,9 @@ def playpos(context, songpos):
raise MpdArgError(u'Bad song index', command=u'play')
def _play_minus_one(context):
if (context.backend.playback.state.get() ==
core.PlaybackController.PLAYING):
if (context.backend.playback.state.get() == PlaybackState.PLAYING):
return # Nothing to do
elif (context.backend.playback.state.get() ==
core.PlaybackController.PAUSED):
elif (context.backend.playback.state.get() == PlaybackState.PAUSED):
return context.backend.playback.resume().get()
elif context.backend.playback.current_cp_track.get() is not None:
cp_track = context.backend.playback.current_cp_track.get()

12
mopidy/frontends/mpd/protocol/status.py
View File

@ -1,6 +1,6 @@
import pykka.future
from mopidy import core
from mopidy.core import PlaybackState
from mopidy.frontends.mpd.exceptions import MpdNotImplemented
from mopidy.frontends.mpd.protocol import handle_request
from mopidy.frontends.mpd.translator import track_to_mpd_format
@ -194,8 +194,8 @@ def status(context):
if futures['playback.current_cp_track'].get() is not None:
result.append(('song', _status_songpos(futures)))
result.append(('songid', _status_songid(futures)))
if futures['playback.state'].get() in (core.PlaybackController.PLAYING,
core.PlaybackController.PAUSED):
if futures['playback.state'].get() in (PlaybackState.PLAYING,
PlaybackState.PAUSED):
result.append(('time', _status_time(futures)))
result.append(('elapsed', _status_time_elapsed(futures)))
result.append(('bitrate', _status_bitrate(futures)))
@ -239,11 +239,11 @@ def _status_songpos(futures):
def _status_state(futures):
state = futures['playback.state'].get()
if state == core.PlaybackController.PLAYING:
if state == PlaybackState.PLAYING:
return u'play'
elif state == core.PlaybackController.STOPPED:
elif state == PlaybackState.STOPPED:
return u'stop'
elif state == core.PlaybackController.PAUSED:
elif state == PlaybackState.PAUSED:
return u'pause'
def _status_time(futures):

17
mopidy/frontends/mpris/objects.py
View File

@ -14,8 +14,9 @@ except ImportError as import_error:
from pykka.registry import ActorRegistry
from mopidy import core, settings
from mopidy import settings
from mopidy.backends.base import Backend
from mopidy.core import PlaybackState
from mopidy.utils.process import exit_process
# Must be done before dbus.SessionBus() is called
@ -197,11 +198,11 @@ class MprisObject(dbus.service.Object):
logger.debug(u'%s.PlayPause not allowed', PLAYER_IFACE)
return
state = self.backend.playback.state.get()
if state == core.PlaybackController.PLAYING:
if state == PlaybackState.PLAYING:
self.backend.playback.pause().get()
elif state == core.PlaybackController.PAUSED:
elif state == PlaybackState.PAUSED:
self.backend.playback.resume().get()
elif state == core.PlaybackController.STOPPED:
elif state == PlaybackState.STOPPED:
self.backend.playback.play().get()
@dbus.service.method(dbus_interface=PLAYER_IFACE)
@ -219,7 +220,7 @@ class MprisObject(dbus.service.Object):
logger.debug(u'%s.Play not allowed', PLAYER_IFACE)
return
state = self.backend.playback.state.get()
if state == core.PlaybackController.PAUSED:
if state == PlaybackState.PAUSED:
self.backend.playback.resume().get()
else:
self.backend.playback.play().get()
@ -286,11 +287,11 @@ class MprisObject(dbus.service.Object):
def get_PlaybackStatus(self):
state = self.backend.playback.state.get()
if state == core.PlaybackController.PLAYING:
if state == PlaybackState.PLAYING:
return 'Playing'
elif state == core.PlaybackController.PAUSED:
elif state == PlaybackState.PAUSED:
return 'Paused'
elif state == core.PlaybackController.STOPPED:
elif state == PlaybackState.STOPPED:
return 'Stopped'
def get_LoopStatus(self):

1
mopidy/models.py
View File

@ -1,5 +1,6 @@
from collections import namedtuple
class ImmutableObject(object):
"""
Superclass for immutable objects whose fields can only be modified via the

9
tests/backends/base/current_playlist.py
View File

@ -2,6 +2,7 @@ import mock
import random
from mopidy import audio
from mopidy.core import PlaybackState
from mopidy.models import CpTrack, Playlist, Track
from tests.backends.base import populate_playlist
@ -71,9 +72,9 @@ class CurrentPlaylistControllerTest(object):
@populate_playlist
def test_clear_when_playing(self):
self.playback.play()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
self.controller.clear()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
def test_get_by_uri_returns_unique_match(self):
track = Track(uri='a')
@ -134,13 +135,13 @@ class CurrentPlaylistControllerTest(object):
self.playback.play()
track = self.playback.current_track
self.controller.append(self.controller.tracks[1:2])
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
self.assertEqual(self.playback.current_track, track)
@populate_playlist
def test_append_preserves_stopped_state(self):
self.controller.append(self.controller.tracks[1:2])
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.assertEqual(self.playback.current_track, None)
def test_index_returns_index_of_track(self):

93
tests/backends/base/playback.py
View File

@ -3,6 +3,7 @@ import random
import time
from mopidy import audio
from mopidy.core import PlaybackState
from mopidy.models import Track
from tests import unittest
@ -26,21 +27,21 @@ class PlaybackControllerTest(object):
'First song needs to be at least 2000 miliseconds'
def test_initial_state_is_stopped(self):
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
def test_play_with_empty_playlist(self):
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.playback.play()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
def test_play_with_empty_playlist_return_value(self):
self.assertEqual(self.playback.play(), None)
@populate_playlist
def test_play_state(self):
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.playback.play()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
@populate_playlist
def test_play_return_value(self):
@ -48,9 +49,9 @@ class PlaybackControllerTest(object):
@populate_playlist
def test_play_track_state(self):
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.playback.play(self.current_playlist.cp_tracks[-1])
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
@populate_playlist
def test_play_track_return_value(self):
@ -70,7 +71,7 @@ class PlaybackControllerTest(object):
track = self.playback.current_track
self.playback.pause()
self.playback.play()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
self.assertEqual(track, self.playback.current_track)
@populate_playlist
@ -81,7 +82,7 @@ class PlaybackControllerTest(object):
track = self.playback.current_track
self.playback.pause()
self.playback.play()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
self.assertEqual(track, self.playback.current_track)
@populate_playlist
@ -106,12 +107,12 @@ class PlaybackControllerTest(object):
def test_current_track_after_completed_playlist(self):
self.playback.play(self.current_playlist.cp_tracks[-1])
self.playback.on_end_of_track()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.assertEqual(self.playback.current_track, None)
self.playback.play(self.current_playlist.cp_tracks[-1])
self.playback.next()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.assertEqual(self.playback.current_track, None)
@populate_playlist
@ -141,17 +142,17 @@ class PlaybackControllerTest(object):
self.playback.next()
self.playback.stop()
self.playback.previous()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@populate_playlist
def test_previous_at_start_of_playlist(self):
self.playback.previous()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.assertEqual(self.playback.current_track, None)
def test_previous_for_empty_playlist(self):
self.playback.previous()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.assertEqual(self.playback.current_track, None)
@populate_playlist
@ -185,20 +186,20 @@ class PlaybackControllerTest(object):
@populate_playlist
def test_next_does_not_trigger_playback(self):
self.playback.next()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@populate_playlist
def test_next_at_end_of_playlist(self):
self.playback.play()
for i, track in enumerate(self.tracks):
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
self.assertEqual(self.playback.current_track, track)
self.assertEqual(self.playback.current_playlist_position, i)
self.playback.next()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@populate_playlist
def test_next_until_end_of_playlist_and_play_from_start(self):
@ -208,15 +209,15 @@ class PlaybackControllerTest(object):
self.playback.next()
self.assertEqual(self.playback.current_track, None)
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.playback.play()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
self.assertEqual(self.playback.current_track, self.tracks[0])
def test_next_for_empty_playlist(self):
self.playback.next()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@populate_playlist
def test_next_skips_to_next_track_on_failure(self):
@ -321,20 +322,20 @@ class PlaybackControllerTest(object):
@populate_playlist
def test_end_of_track_does_not_trigger_playback(self):
self.playback.on_end_of_track()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@populate_playlist
def test_end_of_track_at_end_of_playlist(self):
self.playback.play()
for i, track in enumerate(self.tracks):
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
self.assertEqual(self.playback.current_track, track)
self.assertEqual(self.playback.current_playlist_position, i)
self.playback.on_end_of_track()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@populate_playlist
def test_end_of_track_until_end_of_playlist_and_play_from_start(self):
@ -344,15 +345,15 @@ class PlaybackControllerTest(object):
self.playback.on_end_of_track()
self.assertEqual(self.playback.current_track, None)
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.playback.play()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
self.assertEqual(self.playback.current_track, self.tracks[0])
def test_end_of_track_for_empty_playlist(self):
self.playback.on_end_of_track()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@populate_playlist
def test_end_of_track_skips_to_next_track_on_failure(self):
@ -534,13 +535,13 @@ class PlaybackControllerTest(object):
self.playback.play()
current_track = self.playback.current_track
self.backend.current_playlist.append([self.tracks[2]])
self.assertEqual(self.playback.state, self.playback.PLAYING)
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.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.assertEqual(self.playback.current_track, None)
@populate_playlist
@ -549,26 +550,26 @@ class PlaybackControllerTest(object):
self.playback.pause()
current_track = self.playback.current_track
self.backend.current_playlist.append([self.tracks[2]])
self.assertEqual(self.playback.state, self.backend.playback.PAUSED)
self.assertEqual(self.playback.state, PlaybackState.PAUSED)
self.assertEqual(self.playback.current_track, current_track)
@populate_playlist
def test_pause_when_stopped(self):
self.playback.pause()
self.assertEqual(self.playback.state, self.playback.PAUSED)
self.assertEqual(self.playback.state, PlaybackState.PAUSED)
@populate_playlist
def test_pause_when_playing(self):
self.playback.play()
self.playback.pause()
self.assertEqual(self.playback.state, self.playback.PAUSED)
self.assertEqual(self.playback.state, PlaybackState.PAUSED)
@populate_playlist
def test_pause_when_paused(self):
self.playback.play()
self.playback.pause()
self.playback.pause()
self.assertEqual(self.playback.state, self.playback.PAUSED)
self.assertEqual(self.playback.state, PlaybackState.PAUSED)
@populate_playlist
def test_pause_return_value(self):
@ -578,20 +579,20 @@ class PlaybackControllerTest(object):
@populate_playlist
def test_resume_when_stopped(self):
self.playback.resume()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@populate_playlist
def test_resume_when_playing(self):
self.playback.play()
self.playback.resume()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
@populate_playlist
def test_resume_when_paused(self):
self.playback.play()
self.playback.pause()
self.playback.resume()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
@populate_playlist
def test_resume_return_value(self):
@ -624,12 +625,12 @@ class PlaybackControllerTest(object):
def test_seek_on_empty_playlist_updates_position(self):
self.playback.seek(0)
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@populate_playlist
def test_seek_when_stopped_triggers_play(self):
self.playback.seek(0)
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
@populate_playlist
def test_seek_when_playing(self):
@ -666,7 +667,7 @@ class PlaybackControllerTest(object):
self.playback.play()
self.playback.pause()
self.playback.seek(0)
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
@unittest.SkipTest
@populate_playlist
@ -686,7 +687,7 @@ class PlaybackControllerTest(object):
def test_seek_beyond_end_of_song_for_last_track(self):
self.playback.play(self.current_playlist.cp_tracks[-1])
self.playback.seek(self.current_playlist.tracks[-1].length * 100)
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@unittest.SkipTest
@populate_playlist
@ -702,25 +703,25 @@ class PlaybackControllerTest(object):
self.playback.seek(-1000)
position = self.playback.time_position
self.assert_(position >= 0, position)
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
@populate_playlist
def test_stop_when_stopped(self):
self.playback.stop()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@populate_playlist
def test_stop_when_playing(self):
self.playback.play()
self.playback.stop()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
@populate_playlist
def test_stop_when_paused(self):
self.playback.play()
self.playback.pause()
self.playback.stop()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
def test_stop_return_value(self):
self.playback.play()
@ -810,7 +811,7 @@ class PlaybackControllerTest(object):
def test_end_of_playlist_stops(self):
self.playback.play(self.current_playlist.cp_tracks[-1])
self.playback.on_end_of_track()
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
def test_repeat_off_by_default(self):
self.assertEqual(self.playback.repeat, False)
@ -835,9 +836,9 @@ class PlaybackControllerTest(object):
for _ in self.tracks:
self.playback.next()
self.assertNotEqual(self.playback.track_at_next, None)
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.state, PlaybackState.STOPPED)
self.playback.play()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
@populate_playlist
def test_random_until_end_of_playlist_with_repeat(self):

7
tests/backends/local/playback_test.py
View File

@ -2,6 +2,7 @@ import sys
from mopidy import settings
from mopidy.backends.local import LocalBackend
from mopidy.core import PlaybackState
from mopidy.models import Track
from mopidy.utils.path import path_to_uri
@ -39,14 +40,14 @@ class LocalPlaybackControllerTest(PlaybackControllerTest, unittest.TestCase):
def test_play_mp3(self):
self.add_track('blank.mp3')
self.playback.play()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
def test_play_ogg(self):
self.add_track('blank.ogg')
self.playback.play()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)
def test_play_flac(self):
self.add_track('blank.flac')
self.playback.play()
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.state, PlaybackState.PLAYING)

9
tests/frontends/mpd/protocol/playback_test.py
View File

@ -1,12 +1,13 @@
from mopidy import core
from mopidy.core import PlaybackState
from mopidy.models import Track
from tests import unittest
from tests.frontends.mpd import protocol
PAUSED = core.PlaybackController.PAUSED
PLAYING = core.PlaybackController.PLAYING
STOPPED = core.PlaybackController.STOPPED
PAUSED = PlaybackState.PAUSED
PLAYING = PlaybackState.PLAYING
STOPPED = PlaybackState.STOPPED
class PlaybackOptionsHandlerTest(protocol.BaseTestCase):

9
tests/frontends/mpd/status_test.py
View File

@ -1,14 +1,15 @@
from mopidy import core
from mopidy.backends import dummy
from mopidy.core import PlaybackState
from mopidy.frontends.mpd import dispatcher
from mopidy.frontends.mpd.protocol import status
from mopidy.models import Track
from tests import unittest
PAUSED = core.PlaybackController.PAUSED
PLAYING = core.PlaybackController.PLAYING
STOPPED = core.PlaybackController.STOPPED
PAUSED = PlaybackState.PAUSED
PLAYING = PlaybackState.PLAYING
STOPPED = PlaybackState.STOPPED
# FIXME migrate to using protocol.BaseTestCase instead of status.stats
# directly?

9
tests/frontends/mpris/player_interface_test.py
View File

@ -2,8 +2,9 @@ import sys
import mock
from mopidy import core, OptionalDependencyError
from mopidy import OptionalDependencyError
from mopidy.backends.dummy import DummyBackend
from mopidy.core import PlaybackState
from mopidy.models import Album, Artist, Track
try:
@ -13,9 +14,9 @@ except OptionalDependencyError:
from tests import unittest
PLAYING = core.PlaybackController.PLAYING
PAUSED = core.PlaybackController.PAUSED
STOPPED = core.PlaybackController.STOPPED
PLAYING = PlaybackState.PLAYING
PAUSED = PlaybackState.PAUSED
STOPPED = PlaybackState.STOPPED
@unittest.skipUnless(sys.platform.startswith('linux'), 'requires Linux')