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

CurrentPlaylistController.load() takes a list of tracks instead of a Playlist object

Browse Source
This commit is contained in:
Stein Magnus Jodal 2010-06-29 23:53:52 +02:00
parent 770e1fa85e
commit 4ba30f80e4
5 changed files with 259 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
docs/changes.rst
View File

@ -25,6 +25,13 @@ We got an updated :doc:`release roadmap <development/roadmap>`!
- ``command_list_end`` before ``command_list_start`` now returns unknown
command error instead of crashing.
- Backend API:
- :meth:`mopidy.backends.BaseCurrentPlaylistController.load()` now accepts
lists of :class:`mopidy.models.Track` instead of
:class:`mopidy.models.Playlist`, as none of the other fields on the
``Playlist`` model was in use.
0.1.0a2 (2010-06-02)
====================

58
mopidy/backends/__init__.py
View File

@ -88,20 +88,20 @@ class BaseCurrentPlaylistController(object):
def __init__(self, backend):
self.backend = backend
self._playlist = Playlist()
self._tracks = []
def destroy(self):
"""Cleanup after component."""
pass
@property
def playlist(self):
"""The currently loaded :class:`mopidy.models.Playlist`."""
return copy(self._playlist)
def tracks(self):
"""List of :class:`mopidy.model.Track` in the current playlist."""
return copy(self._tracks)
@playlist.setter
def playlist(self, new_playlist):
self._playlist = new_playlist
@tracks.setter
def tracks(self, new_tracks):
self._tracks = copy(new_tracks)
self.version += 1
def add(self, track, at_position=None):
@ -114,7 +114,7 @@ class BaseCurrentPlaylistController(object):
:param at_position: position in current playlist to add track
:type at_position: int or :class:`None`
"""
tracks = self.playlist.tracks
tracks = self.tracks
assert at_position <= len(tracks), 'at_position can not be greater' \
+ ' than playlist length'
@ -123,13 +123,13 @@ class BaseCurrentPlaylistController(object):
tracks.insert(at_position, track)
else:
tracks.append(track)
self.playlist = self.playlist.with_(tracks=tracks)
self.tracks = tracks
def clear(self):
"""Clear the current playlist."""
self.backend.playback.stop()
self.backend.playback.current_track = None
self.playlist = Playlist()
self.tracks = []
def get(self, **criteria):
"""
@ -147,7 +147,7 @@ class BaseCurrentPlaylistController(object):
:type criteria: dict
:rtype: :class:`mopidy.models.Track`
"""
matches = self._playlist.tracks
matches = self.tracks
for (key, value) in criteria.iteritems():
matches = filter(lambda t: getattr(t, key) == value, matches)
if len(matches) == 1:
@ -159,14 +159,14 @@ class BaseCurrentPlaylistController(object):
else:
raise LookupError(u'"%s" match multiple tracks' % criteria_string)
def load(self, playlist):
def load(self, tracks):
"""
Replace the current playlist with the given playlist.
Replace the tracks in the current playlist with the given tracks.
:param playlist: playlist to load
:type playlist: :class:`mopidy.models.Playlist`
:param tracks: tracks to load
:type tracks: list of :class:`mopidy.models.Track`
"""
self.playlist = playlist
self.tracks = tracks
self.backend.playback.new_playlist_loaded_callback()
def move(self, start, end, to_position):
@ -183,7 +183,7 @@ class BaseCurrentPlaylistController(object):
if start == end:
end += 1
tracks = self.playlist.tracks
tracks = self.tracks
assert start < end, 'start must be smaller than end'
assert start >= 0, 'start must be at least zero'
@ -196,7 +196,7 @@ class BaseCurrentPlaylistController(object):
for track in tracks[start:end]:
new_tracks.insert(to_position, track)
to_position += 1
self.playlist = self.playlist.with_(tracks=new_tracks)
self.tracks = new_tracks
def remove(self, track):
"""
@ -205,13 +205,13 @@ class BaseCurrentPlaylistController(object):
:param track: track to remove
:type track: :class:`mopidy.models.Track`
"""
tracks = self.playlist.tracks
tracks = self.tracks
assert track in tracks, 'track must be in playlist'
position = tracks.index(track)
del tracks[position]
self.playlist = self.playlist.with_(tracks=tracks)
self.tracks = tracks
def shuffle(self, start=None, end=None):
"""
@ -223,7 +223,7 @@ class BaseCurrentPlaylistController(object):
:param end: position after last track to shuffle
:type end: int or :class:`None`
"""
tracks = self.playlist.tracks
tracks = self.tracks
if start is not None and end is not None:
assert start < end, 'start must be smaller than end'
@ -239,12 +239,16 @@ class BaseCurrentPlaylistController(object):
shuffled = tracks[start:end]
after = tracks[end or len(tracks):]
random.shuffle(shuffled)
self.playlist = self.playlist.with_(tracks=before+shuffled+after)
self.tracks = before + shuffled + after
def destroy(self):
"""Cleanup after component."""
pass
def mpd_format(self, *args, **kwargs):
# XXX Lazy workaround to make tests pass while refactoring
return Playlist(tracks=self.tracks).mpd_format(*args, **kwargs)
class BaseLibraryController(object):
"""
@ -364,7 +368,7 @@ class BasePlaybackController(object):
if self.current_track is None:
return None
try:
return self.backend.current_playlist.playlist.tracks.index(
return self.backend.current_playlist.tracks.index(
self.current_track)
except ValueError:
return None
@ -379,7 +383,7 @@ class BasePlaybackController(object):
enabled this should be a random track, all tracks should be played once
before the list repeats.
"""
tracks = self.backend.current_playlist.playlist.tracks
tracks = self.backend.current_playlist.tracks
if not tracks:
return None
@ -420,7 +424,7 @@ class BasePlaybackController(object):
if self.current_track is None or self.current_playlist_position == 0:
return None
return self.backend.current_playlist.playlist.tracks[
return self.backend.current_playlist.tracks[
self.current_playlist_position - 1]
@property
@ -508,7 +512,7 @@ class BasePlaybackController(object):
self._shuffled = []
if self.state == self.PLAYING:
if self.backend.current_playlist.playlist.length > 0:
if len(self.backend.current_playlist.tracks) > 0:
self.play()
else:
self.stop()
@ -555,7 +559,7 @@ class BasePlaybackController(object):
"""
if track:
assert track in self.backend.current_playlist.playlist.tracks
assert track in self.backend.current_playlist.tracks
elif not self.current_track:
track = self.next_track

43
mopidy/mpd/frontend.py
View File

@ -271,7 +271,7 @@ class MpdFrontend(object):
track = self.backend.library.lookup(uri)
if track is None:
raise MpdNoExistError(u'No such song', command=u'addid')
if songpos and songpos > self.backend.current_playlist.playlist.length:
if songpos and songpos > len(self.backend.current_playlist.tracks):
raise MpdArgError(u'Bad song index', command=u'addid')
self.backend.current_playlist.add(track, at_position=songpos)
return ('Id', track.id)
@ -289,8 +289,8 @@ class MpdFrontend(object):
if end is not None:
end = int(end)
else:
end = self.backend.current_playlist.playlist.length
tracks = self.backend.current_playlist.playlist.tracks[start:end]
end = len(self.backend.current_playlist.tracks)
tracks = self.backend.current_playlist.tracks[start:end]
if not tracks:
raise MpdArgError(u'Bad song index', command=u'delete')
for track in tracks:
@ -301,7 +301,7 @@ class MpdFrontend(object):
"""See :meth:`_current_playlist_delete_range`"""
try:
songpos = int(songpos)
track = self.backend.current_playlist.playlist.tracks[songpos]
track = self.backend.current_playlist.tracks[songpos]
self.backend.current_playlist.remove(track)
except IndexError:
raise MpdArgError(u'Bad song index', command=u'delete')
@ -344,7 +344,7 @@ class MpdFrontend(object):
``TO`` in the playlist.
"""
if end is None:
end = self.backend.current_playlist.playlist.length
end = len(self.backend.current_playlist.tracks)
start = int(start)
end = int(end)
to = int(to)
@ -371,7 +371,7 @@ class MpdFrontend(object):
songid = int(songid)
to = int(to)
track = self.backend.current_playlist.get(id=songid)
position = self.backend.current_playlist.playlist.tracks.index(track)
position = self.backend.current_playlist.tracks.index(track)
self.backend.current_playlist.move(position, position + 1, to)
@handle_pattern(r'^playlist$')
@ -429,7 +429,7 @@ class MpdFrontend(object):
except LookupError:
raise MpdNoExistError(u'No such song', command=u'playlistid')
else:
return self.backend.current_playlist.playlist.mpd_format()
return self.backend.current_playlist.mpd_format()
@handle_pattern(r'^playlistinfo$')
@handle_pattern(r'^playlistinfo "(?P<songpos>-?\d+)"$')
@ -459,15 +459,14 @@ class MpdFrontend(object):
end = songpos + 1
if start == -1:
end = None
return self.backend.current_playlist.playlist.mpd_format(
start, end)
return self.backend.current_playlist.mpd_format(start, end)
else:
if start is None:
start = 0
start = int(start)
if end is not None:
end = int(end)
return self.backend.current_playlist.playlist.mpd_format(start, end)
return self.backend.current_playlist.mpd_format(start, end)
@handle_pattern(r'^playlistsearch "(?P<tag>[^"]+)" "(?P<needle>[^"]+)"$')
def _current_playlist_playlistsearch(self, tag, needle):
@ -495,7 +494,7 @@ class MpdFrontend(object):
"""
# XXX Naive implementation that returns all tracks as changed
if int(version) < self.backend.current_playlist.version:
return self.backend.current_playlist.playlist.mpd_format()
return self.backend.current_playlist.mpd_format()
@handle_pattern(r'^plchangesposid "(?P<version>\d+)"$')
def _current_playlist_plchangesposid(self, version):
@ -515,7 +514,7 @@ class MpdFrontend(object):
if int(version) != self.backend.current_playlist.version:
result = []
for position, track in enumerate(
self.backend.current_playlist.playlist.tracks):
self.backend.current_playlist.tracks):
result.append((u'cpos', position))
result.append((u'Id', track.id))
return result
@ -548,15 +547,14 @@ class MpdFrontend(object):
"""
songpos1 = int(songpos1)
songpos2 = int(songpos2)
playlist = self.backend.current_playlist.playlist
tracks = playlist.tracks
tracks = self.backend.current_playlist.tracks
song1 = tracks[songpos1]
song2 = tracks[songpos2]
del tracks[songpos1]
tracks.insert(songpos1, song2)
del tracks[songpos2]
tracks.insert(songpos2, song1)
self.backend.current_playlist.load(playlist.with_(tracks=tracks))
self.backend.current_playlist.load(tracks)
@handle_pattern(r'^swapid "(?P<songid1>\d+)" "(?P<songid2>\d+)"$')
def _current_playlist_swapid(self, songid1, songid2):
@ -571,8 +569,8 @@ class MpdFrontend(object):
songid2 = int(songid2)
song1 = self.backend.current_playlist.get(id=songid1)
song2 = self.backend.current_playlist.get(id=songid2)
songpos1 = self.backend.current_playlist.playlist.tracks.index(song1)
songpos2 = self.backend.current_playlist.playlist.tracks.index(song2)
songpos1 = self.backend.current_playlist.tracks.index(song1)
songpos2 = self.backend.current_playlist.tracks.index(song2)
self._current_playlist_swap(songpos1, songpos2)
@handle_pattern(r'^$')
@ -897,7 +895,7 @@ class MpdFrontend(object):
songid = int(songid)
try:
if songid == -1:
track = self.backend.current_playlist.playlist.tracks[0]
track = self.backend.current_playlist.tracks[0]
else:
track = self.backend.current_playlist.get(id=songid)
return self.backend.playback.play(track)
@ -921,9 +919,9 @@ class MpdFrontend(object):
songpos = int(songpos)
try:
if songpos == -1:
track = self.backend.current_playlist.playlist.tracks[0]
track = self.backend.current_playlist.tracks[0]
else:
track = self.backend.current_playlist.playlist.tracks[songpos]
track = self.backend.current_playlist.tracks[songpos]
return self.backend.playback.play(track)
except IndexError:
raise MpdArgError(u'Bad song index', command=u'play')
@ -1332,7 +1330,7 @@ class MpdFrontend(object):
return 0
def __status_status_playlist_length(self):
return self.backend.current_playlist.playlist.length
return len(self.backend.current_playlist.tracks)
def __status_status_playlist_version(self):
return self.backend.current_playlist.version
@ -1537,8 +1535,7 @@ class MpdFrontend(object):
"""
matches = self.backend.stored_playlists.search(name)
if matches:
self.backend.current_playlist.load(matches[0])
self.backend.playback.new_playlist_loaded_callback() # FIXME not needed?
self.backend.current_playlist.load(matches[0].tracks)
@handle_pattern(r'^playlistadd "(?P<name>[^"]+)" "(?P<uri>[^"]+)"$')
def _stored_playlist_playlistadd(self, name, uri):

115
tests/backends/base.py
View File

@ -44,12 +44,12 @@ class BaseCurrentPlaylistControllerTest(object):
def test_add(self):
for track in self.tracks:
self.controller.add(track)
self.assertEqual(track, self.controller.playlist.tracks[-1])
self.assertEqual(track, self.controller.tracks[-1])
def test_add_at_position(self):
for track in self.tracks[:-1]:
self.controller.add(track, 0)
self.assertEqual(track, self.controller.playlist.tracks[0])
self.assertEqual(track, self.controller.tracks[0])
@populate_playlist
def test_add_at_position_outside_of_playlist(self):
@ -58,12 +58,12 @@ class BaseCurrentPlaylistControllerTest(object):
@populate_playlist
def test_add_sets_id_property(self):
for track in self.controller.playlist.tracks:
for track in self.controller.tracks:
self.assertNotEqual(None, track.id)
@populate_playlist
def test_get_by_id(self):
track = self.controller.playlist.tracks[1]
track = self.controller.tracks[1]
self.assertEqual(track, self.controller.get(id=track.id))
@populate_playlist
@ -72,7 +72,7 @@ class BaseCurrentPlaylistControllerTest(object):
@populate_playlist
def test_get_by_uri(self):
track = self.controller.playlist.tracks[1]
track = self.controller.tracks[1]
self.assertEqual(track, self.controller.get(uri=track.uri))
@populate_playlist
@ -83,11 +83,11 @@ class BaseCurrentPlaylistControllerTest(object):
@populate_playlist
def test_clear(self):
self.controller.clear()
self.assertEqual(len(self.controller.playlist.tracks), 0)
self.assertEqual(len(self.controller.tracks), 0)
def test_clear_empty_playlist(self):
self.controller.clear()
self.assertEqual(len(self.controller.playlist.tracks), 0)
self.assertEqual(len(self.controller.tracks), 0)
@populate_playlist
def test_clear_when_playing(self):
@ -97,21 +97,19 @@ class BaseCurrentPlaylistControllerTest(object):
self.assertEqual(self.playback.state, self.playback.STOPPED)
def test_load(self):
new_playlist = Playlist()
self.assertNotEqual(id(new_playlist), id(self.controller.playlist))
self.controller.load(new_playlist)
# FIXME how do we test this without going into internals?
self.assertEqual(new_playlist, self.controller._playlist)
tracks = []
self.assertNotEqual(id(tracks), id(self.controller.tracks))
self.controller.load(tracks)
self.assertEqual(tracks, self.controller.tracks)
def test_get_by_id_returns_unique_match(self):
track = Track(id=1)
self.controller.playlist = Playlist(
tracks=[Track(id=13), track, Track(id=17)])
self.controller.load([Track(id=13), track, Track(id=17)])
self.assertEqual(track, self.controller.get(id=1))
def test_get_by_id_raises_error_if_multiple_matches(self):
track = Track(id=1)
self.controller.playlist = Playlist(tracks=[Track(id=13), track, track])
self.controller.load([Track(id=13), track, track])
try:
self.controller.get(id=1)
self.fail(u'Should raise LookupError if multiple matches')
@ -128,14 +126,12 @@ class BaseCurrentPlaylistControllerTest(object):
def test_get_by_uri_returns_unique_match(self):
track = Track(uri='a')
self.controller.playlist = Playlist(
tracks=[Track(uri='z'), track, Track(uri='y')])
self.controller.load([Track(uri='z'), track, Track(uri='y')])
self.assertEqual(track, self.controller.get(uri='a'))
def test_get_by_uri_raises_error_if_multiple_matches(self):
track = Track(uri='a')
self.controller.playlist = Playlist(
tracks=[Track(uri='z'), track, track])
self.controller.load([Track(uri='z'), track, track])
try:
self.controller.get(uri='a')
self.fail(u'Should raise LookupError if multiple matches')
@ -155,7 +151,7 @@ class BaseCurrentPlaylistControllerTest(object):
track1 = Track(id=1, uri='a')
track2 = Track(id=1, uri='b')
track3 = Track(id=2, uri='b')
self.controller.playlist = Playlist(tracks=[track1, track2, track3])
self.controller.load([track1, track2, track3])
self.assertEqual(track1, self.controller.get(id=1, uri='a'))
self.assertEqual(track2, self.controller.get(id=1, uri='b'))
self.assertEqual(track3, self.controller.get(id=2, uri='b'))
@ -164,14 +160,13 @@ class BaseCurrentPlaylistControllerTest(object):
track1 = Track(id=1)
track2 = Track(uri='b')
track3 = Track(id=2)
self.controller.playlist = Playlist(tracks=[track1, track2, track3])
self.controller.load([track1, track2, track3])
self.assertEqual(track1, self.controller.get(id=1))
@populate_playlist
def test_load_replaces_playlist(self):
self.backend.current_playlist.load(Playlist())
tracks = self.backend.current_playlist.playlist.tracks
self.assertEqual(len(tracks), 0)
self.backend.current_playlist.load([])
self.assertEqual(len(self.backend.current_playlist.tracks), 0)
def test_load_does_not_reset_version(self):
version = self.controller.version
@ -181,20 +176,20 @@ class BaseCurrentPlaylistControllerTest(object):
@populate_playlist
def test_load_preserves_playing_state(self):
tracks = self.controller.playlist.tracks
tracks = self.controller.tracks
playback = self.playback
self.playback.play()
self.controller.load(Playlist(tracks=[tracks[1]]))
self.controller.load([tracks[1]])
self.assertEqual(playback.state, playback.PLAYING)
self.assertEqual(tracks[1], self.playback.current_track)
@populate_playlist
def test_load_preserves_stopped_state(self):
tracks = self.controller.playlist.tracks
tracks = self.controller.tracks
playback = self.playback
self.controller.load(Playlist(tracks=[tracks[2]]))
self.controller.load([tracks[2]])
self.assertEqual(playback.state, playback.STOPPED)
self.assertEqual(None, self.playback.current_track)
@ -202,32 +197,32 @@ class BaseCurrentPlaylistControllerTest(object):
def test_move_single(self):
self.controller.move(0, 0, 2)
tracks = self.controller.playlist.tracks
tracks = self.controller.tracks
self.assertEqual(tracks[2], self.tracks[0])
@populate_playlist
def test_move_group(self):
self.controller.move(0, 2, 1)
tracks = self.controller.playlist.tracks
tracks = self.controller.tracks
self.assertEqual(tracks[1], self.tracks[0])
self.assertEqual(tracks[2], self.tracks[1])
@populate_playlist
def test_moving_track_outside_of_playlist(self):
tracks = len(self.controller.playlist.tracks)
tracks = len(self.controller.tracks)
test = lambda: self.controller.move(0, 0, tracks+5)
self.assertRaises(AssertionError, test)
@populate_playlist
def test_move_group_outside_of_playlist(self):
tracks = len(self.controller.playlist.tracks)
tracks = len(self.controller.tracks)
test = lambda: self.controller.move(0, 2, tracks+5)
self.assertRaises(AssertionError, test)
@populate_playlist
def test_move_group_out_of_range(self):
tracks = len(self.controller.playlist.tracks)
tracks = len(self.controller.tracks)
test = lambda: self.controller.move(tracks+2, tracks+3, 0)
self.assertRaises(AssertionError, test)
@ -236,19 +231,18 @@ class BaseCurrentPlaylistControllerTest(object):
test = lambda: self.controller.move(2, 1, 0)
self.assertRaises(AssertionError, test)
def test_playlist_attribute_is_immutable(self):
playlist1 = self.controller.playlist
playlist2 = self.controller.playlist
self.assertNotEqual(id(playlist1), id(playlist2))
def test_tracks_attribute_is_immutable(self):
tracks1 = self.controller.tracks
tracks2 = self.controller.tracks
self.assertNotEqual(id(tracks1), id(tracks2))
@populate_playlist
def test_remove(self):
track1 = self.controller.playlist.tracks[1]
track2 = self.controller.playlist.tracks[2]
track1 = self.controller.tracks[1]
track2 = self.controller.tracks[2]
self.controller.remove(track1)
self.assert_(track1 not in self.controller.playlist.tracks)
self.assertEqual(track2, self.controller.playlist.tracks[1])
self.assert_(track1 not in self.controller.tracks)
self.assertEqual(track2, self.controller.tracks[1])
@populate_playlist
def test_removing_track_that_does_not_exist(self):
@ -264,7 +258,7 @@ class BaseCurrentPlaylistControllerTest(object):
random.seed(1)
self.controller.shuffle()
shuffled_tracks = self.controller.playlist.tracks
shuffled_tracks = self.controller.tracks
self.assertNotEqual(self.tracks, shuffled_tracks)
self.assertEqual(set(self.tracks), set(shuffled_tracks))
@ -274,7 +268,7 @@ class BaseCurrentPlaylistControllerTest(object):
random.seed(1)
self.controller.shuffle(1, 3)
shuffled_tracks = self.controller.playlist.tracks
shuffled_tracks = self.controller.tracks
self.assertNotEqual(self.tracks, shuffled_tracks)
self.assertEqual(self.tracks[0], shuffled_tracks[0])
@ -287,7 +281,7 @@ class BaseCurrentPlaylistControllerTest(object):
@populate_playlist
def test_shuffle_superset(self):
tracks = len(self.controller.playlist.tracks)
tracks = len(self.controller.tracks)
test = lambda: self.controller.shuffle(1, tracks+5)
self.assertRaises(AssertionError, test)
@ -296,7 +290,7 @@ class BaseCurrentPlaylistControllerTest(object):
random.seed(1)
self.controller.shuffle(1)
shuffled_tracks = self.controller.playlist.tracks
shuffled_tracks = self.controller.tracks
self.assertNotEqual(self.tracks, shuffled_tracks)
self.assertEqual(self.tracks[0], shuffled_tracks[0])
@ -304,8 +298,8 @@ class BaseCurrentPlaylistControllerTest(object):
def test_version(self):
version = self.controller.version
self.controller.playlist = Playlist()
self.assertEqual(version+1, self.controller.version)
self.controller.tracks = []
self.assertEqual(self.controller.version, version + 1)
class BasePlaybackControllerTest(object):
@ -639,26 +633,23 @@ class BasePlaybackControllerTest(object):
@populate_playlist
def test_new_playlist_loaded_callback_when_playing(self):
playlist = Playlist(tracks=[self.tracks[2]])
self.playback.play()
self.backend.current_playlist.load(playlist)
self.backend.current_playlist.load([self.tracks[2]])
self.assertEqual(self.playback.state, self.playback.PLAYING)
self.assertEqual(self.playback.current_track, self.tracks[2])
@populate_playlist
def test_new_playlist_loaded_callback_when_stopped(self):
playlist = Playlist(tracks=[self.tracks[2]])
self.backend.current_playlist.load(playlist)
self.backend.current_playlist.load([self.tracks[2]])
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.current_track, None)
self.assertEqual(self.playback.next_track, self.tracks[2])
@populate_playlist
def test_new_playlist_loaded_callback_when_paused(self):
playlist = Playlist(tracks=[self.tracks[2]])
self.playback.play()
self.playback.pause()
self.backend.current_playlist.load(playlist)
self.backend.current_playlist.load([self.tracks[2]])
self.assertEqual(self.playback.state, self.playback.STOPPED)
self.assertEqual(self.playback.current_track, None)
self.assertEqual(self.playback.next_track, self.tracks[2])
@ -735,7 +726,7 @@ class BasePlaybackControllerTest(object):
@populate_playlist
def test_seek_when_playing(self):
length = self.backend.current_playlist.playlist.tracks[0].length
length = self.backend.current_playlist.tracks[0].length
self.playback.play()
self.playback.seek(length - 1000)
position = self.playback.time_position
@ -743,7 +734,7 @@ class BasePlaybackControllerTest(object):
@populate_playlist
def test_seek_when_paused(self):
length = self.backend.current_playlist.playlist.tracks[0].length
length = self.backend.current_playlist.tracks[0].length
self.playback.play()
self.playback.pause()
self.playback.seek(length - 1000)
@ -842,16 +833,15 @@ class BasePlaybackControllerTest(object):
self.playback.consume = True
self.playback.play()
self.playback.next()
tracks = self.backend.current_playlist.playlist.tracks
self.assert_(self.tracks[0] not in tracks)
self.assert_(self.tracks[0] not in self.backend.current_playlist.tracks)
@populate_playlist
def test_playlist_is_empty_after_all_tracks_are_played_with_consume(self):
self.playback.consume = True
self.playback.play()
for i in range(len(self.backend.current_playlist.playlist.tracks)):
for i in range(len(self.backend.current_playlist.tracks)):
self.playback.next()
self.assertEqual(len(self.backend.current_playlist.playlist.tracks), 0)
self.assertEqual(len(self.backend.current_playlist.tracks), 0)
@populate_playlist
def test_play_with_random(self):
@ -932,7 +922,7 @@ class BasePlaybackControllerTest(object):
random.seed(1)
self.playback.random = True
self.assertEqual(self.playback.next_track, self.tracks[2])
self.backend.current_playlist.load(Playlist(tracks=self.tracks[:1]))
self.backend.current_playlist.load(self.tracks[:1])
self.assertEqual(self.playback.next_track, self.tracks[0])
@populate_playlist
@ -946,8 +936,7 @@ class BasePlaybackControllerTest(object):
self.playback.next()
def test_playing_track_with_invalid_uri(self):
playlist = Playlist(tracks=[Track(uri='foobar')])
self.backend.current_playlist.load(playlist)
self.backend.current_playlist.load([Track(uri='foobar')])
self.playback.play()
self.assertEqual(self.playback.state, self.playback.STOPPED)

286
tests/mpd/frontend_test.py
View File

@ -118,7 +118,7 @@ class StatusHandlerTest(unittest.TestCase):
def test_currentsong(self):
track = Track()
self.b.current_playlist.playlist = Playlist(tracks=[track])
self.b.current_playlist.load([track])
self.b.playback.current_track = track
result = self.h.handle_request(u'currentsong')
self.assert_(u'file: ' in result)
@ -258,7 +258,7 @@ class StatusHandlerTest(unittest.TestCase):
def test_status_method_when_playlist_loaded_contains_song(self):
track = Track()
self.b.current_playlist.load(Playlist(tracks=[track]))
self.b.current_playlist.load([track])
self.b.playback.current_track = track
result = dict(self.h._status_status())
self.assert_('song' in result)
@ -266,7 +266,7 @@ class StatusHandlerTest(unittest.TestCase):
def test_status_method_when_playlist_loaded_contains_pos_as_songid(self):
track = Track()
self.b.current_playlist.load(Playlist(tracks=[track]))
self.b.current_playlist.load([track])
self.b.playback.current_track = track
result = dict(self.h._status_status())
self.assert_('songid' in result)
@ -274,7 +274,7 @@ class StatusHandlerTest(unittest.TestCase):
def test_status_method_when_playlist_loaded_contains_id_as_songid(self):
track = Track(id=1)
self.b.current_playlist.load(Playlist(tracks=[track]))
self.b.current_playlist.load([track])
self.b.playback.current_track = track
result = dict(self.h._status_status())
self.assert_('songid' in result)
@ -447,7 +447,7 @@ class PlaybackControlHandlerTest(unittest.TestCase):
def test_pause_off(self):
track = Track()
self.b.current_playlist.playlist = Playlist(tracks=[track])
self.b.current_playlist.load([track])
self.b.playback.current_track = track
self.h.handle_request(u'play "0"')
self.h.handle_request(u'pause "1"')
@ -457,7 +457,7 @@ class PlaybackControlHandlerTest(unittest.TestCase):
def test_pause_on(self):
track = Track()
self.b.current_playlist.playlist = Playlist(tracks=[track])
self.b.current_playlist.load([track])
self.b.playback.current_track = track
self.h.handle_request(u'play "0"')
result = self.h.handle_request(u'pause "1"')
@ -466,7 +466,7 @@ class PlaybackControlHandlerTest(unittest.TestCase):
def test_play_without_pos(self):
track = Track()
self.b.current_playlist.playlist = Playlist(tracks=[track])
self.b.current_playlist.load([track])
self.b.playback.current_track = track
self.b.playback.state = self.b.playback.PAUSED
result = self.h.handle_request(u'play')
@ -474,41 +474,41 @@ class PlaybackControlHandlerTest(unittest.TestCase):
self.assertEqual(self.b.playback.PLAYING, self.b.playback.state)
def test_play_with_pos(self):
self.b.current_playlist.load(Playlist(tracks=[Track()]))
self.b.current_playlist.load([Track()])
result = self.h.handle_request(u'play "0"')
self.assert_(u'OK' in result)
self.assertEqual(self.b.playback.PLAYING, self.b.playback.state)
def test_play_with_pos_out_of_bounds(self):
self.b.current_playlist.load(Playlist())
self.b.current_playlist.load([])
result = self.h.handle_request(u'play "0"')
self.assertEqual(result[0], u'ACK [2@0] {play} Bad song index')
self.assertEqual(self.b.playback.STOPPED, self.b.playback.state)
def test_play_minus_one_plays_first_in_playlist(self):
track = Track(id=0)
self.b.current_playlist.load(Playlist(tracks=[track]))
self.b.current_playlist.load([track])
result = self.h.handle_request(u'play "-1"')
self.assert_(u'OK' in result)
self.assertEqual(self.b.playback.PLAYING, self.b.playback.state)
self.assertEqual(self.b.playback.current_track, track)
def test_playid(self):
self.b.current_playlist.load(Playlist(tracks=[Track(id=0)]))
self.b.current_playlist.load([Track(id=0)])
result = self.h.handle_request(u'playid "0"')
self.assert_(u'OK' in result)
self.assertEqual(self.b.playback.PLAYING, self.b.playback.state)
def test_playid_minus_one_plays_first_in_playlist(self):
track = Track(id=0)
self.b.current_playlist.load(Playlist(tracks=[track]))
self.b.current_playlist.load([track])
result = self.h.handle_request(u'playid "-1"')
self.assert_(u'OK' in result)
self.assertEqual(self.b.playback.PLAYING, self.b.playback.state)
self.assertEqual(self.b.playback.current_track, track)
def test_playid_which_does_not_exist(self):
self.b.current_playlist.load(Playlist(tracks=[Track(id=0)]))
self.b.current_playlist.load([Track(id=0)])
result = self.h.handle_request(u'playid "1"')
self.assertEqual(result[0], u'ACK [50@0] {playid} No such song')
@ -539,12 +539,12 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
def test_add(self):
needle = Track(uri='dummy://foo')
self.b.library._library = [Track(), Track(), needle, Track()]
self.b.current_playlist.playlist = Playlist(
tracks=[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.b.current_playlist.load(
[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5)
result = self.h.handle_request(u'add "dummy://foo"')
self.assertEqual(self.b.current_playlist.playlist.length, 6)
self.assertEqual(self.b.current_playlist.playlist.tracks[5], needle)
self.assertEqual(len(self.b.current_playlist.tracks), 6)
self.assertEqual(self.b.current_playlist.tracks[5], needle)
self.assertEqual(len(result), 1)
self.assert_(u'OK' in result)
@ -556,33 +556,33 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
def test_addid_without_songpos(self):
needle = Track(uri='dummy://foo', id=137)
self.b.library._library = [Track(), Track(), needle, Track()]
self.b.current_playlist.playlist = Playlist(
tracks=[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.b.current_playlist.load(
[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5)
result = self.h.handle_request(u'addid "dummy://foo"')
self.assertEqual(self.b.current_playlist.playlist.length, 6)
self.assertEqual(self.b.current_playlist.playlist.tracks[5], needle)
self.assertEqual(len(self.b.current_playlist.tracks), 6)
self.assertEqual(self.b.current_playlist.tracks[5], needle)
self.assert_(u'Id: 137' in result)
self.assert_(u'OK' in result)
def test_addid_with_songpos(self):
needle = Track(uri='dummy://foo', id=137)
self.b.library._library = [Track(), Track(), needle, Track()]
self.b.current_playlist.playlist = Playlist(
tracks=[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.b.current_playlist.load(
[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5)
result = self.h.handle_request(u'addid "dummy://foo" "3"')
self.assertEqual(self.b.current_playlist.playlist.length, 6)
self.assertEqual(self.b.current_playlist.playlist.tracks[3], needle)
self.assertEqual(len(self.b.current_playlist.tracks), 6)
self.assertEqual(self.b.current_playlist.tracks[3], needle)
self.assert_(u'Id: 137' in result)
self.assert_(u'OK' in result)
def test_addid_with_songpos_out_of_bounds_should_ack(self):
needle = Track(uri='dummy://foo', id=137)
self.b.library._library = [Track(), Track(), needle, Track()]
self.b.current_playlist.playlist = Playlist(
tracks=[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.b.current_playlist.load(
[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5)
result = self.h.handle_request(u'addid "dummy://foo" "6"')
self.assertEqual(result[0], u'ACK [2@0] {addid} Bad song index')
@ -591,118 +591,122 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
self.assertEqual(result[0], u'ACK [50@0] {addid} No such song')
def test_clear(self):
self.b.current_playlist.playlist = Playlist(
tracks=[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.b.current_playlist.load(
[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5)
result = self.h.handle_request(u'clear')
self.assertEqual(self.b.current_playlist.playlist.length, 0)
self.assertEqual(len(self.b.current_playlist.tracks), 0)
self.assertEqual(self.b.playback.current_track, None)
self.assert_(u'OK' in result)
def test_delete_songpos(self):
self.b.current_playlist.playlist = Playlist(
tracks=[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.b.current_playlist.load(
[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5)
result = self.h.handle_request(u'delete "2"')
self.assertEqual(self.b.current_playlist.playlist.length, 4)
self.assertEqual(len(self.b.current_playlist.tracks), 4)
self.assert_(u'OK' in result)
def test_delete_songpos_out_of_bounds(self):
self.b.current_playlist.playlist = Playlist(
tracks=[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.b.current_playlist.load(
[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5)
result = self.h.handle_request(u'delete "5"')
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.assertEqual(len(self.b.current_playlist.tracks), 5)
self.assertEqual(result[0], u'ACK [2@0] {delete} Bad song index')
def test_delete_open_range(self):
self.b.current_playlist.playlist = Playlist(
tracks=[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.b.current_playlist.load(
[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5)
result = self.h.handle_request(u'delete "1:"')
self.assertEqual(self.b.current_playlist.playlist.length, 1)
self.assertEqual(len(self.b.current_playlist.tracks), 1)
self.assert_(u'OK' in result)
def test_delete_closed_range(self):
self.b.current_playlist.playlist = Playlist(
tracks=[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.b.current_playlist.load(
[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5)
result = self.h.handle_request(u'delete "1:3"')
self.assertEqual(self.b.current_playlist.playlist.length, 3)
self.assertEqual(len(self.b.current_playlist.tracks), 3)
self.assert_(u'OK' in result)
def test_delete_range_out_of_bounds(self):
self.b.current_playlist.playlist = Playlist(
tracks=[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.b.current_playlist.load(
[Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5)
result = self.h.handle_request(u'delete "5:7"')
self.assertEqual(self.b.current_playlist.playlist.length, 5)
self.assertEqual(len(self.b.current_playlist.tracks), 5)
self.assertEqual(result[0], u'ACK [2@0] {delete} Bad song index')
def test_deleteid(self):
self.b.current_playlist.load(Playlist(tracks=[Track(id=0), Track()]))
self.assertEqual(self.b.current_playlist.playlist.length, 2)
self.b.current_playlist.load([Track(id=0), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 2)
result = self.h.handle_request(u'deleteid "0"')
self.assertEqual(self.b.current_playlist.playlist.length, 1)
self.assertEqual(len(self.b.current_playlist.tracks), 1)
self.assert_(u'OK' in result)
def test_deleteid_does_not_exist(self):
self.b.current_playlist.load(Playlist(tracks=[Track(id=1), Track()]))
self.assertEqual(self.b.current_playlist.playlist.length, 2)
self.b.current_playlist.load([Track(id=1), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 2)
result = self.h.handle_request(u'deleteid "0"')
self.assertEqual(self.b.current_playlist.playlist.length, 2)
self.assertEqual(len(self.b.current_playlist.tracks), 2)
self.assertEqual(result[0], u'ACK [50@0] {deleteid} No such song')
def test_move_songpos(self):
self.b.current_playlist.load(Playlist(tracks=[
self.b.current_playlist.load([
Track(name='a'), Track(name='b'), Track(name='c'),
Track(name='d'), Track(name='e'), Track(name='f')]))
Track(name='d'), Track(name='e'), Track(name='f'),
])
result = self.h.handle_request(u'move "1" "0"')
self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'b')
self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'a')
self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'c')
self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'e')
self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'b')
self.assertEqual(self.b.current_playlist.tracks[1].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'e')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
self.assert_(u'OK' in result)
def test_move_open_range(self):
self.b.current_playlist.load(Playlist(tracks=[
self.b.current_playlist.load([
Track(name='a'), Track(name='b'), Track(name='c'),
Track(name='d'), Track(name='e'), Track(name='f')]))
Track(name='d'), Track(name='e'), Track(name='f'),
])
result = self.h.handle_request(u'move "2:" "0"')
self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'c')
self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'd')
self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'e')
self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'f')
self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'a')
self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'b')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[1].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'e')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'f')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'b')
self.assert_(u'OK' in result)
def test_move_closed_range(self):
self.b.current_playlist.load(Playlist(tracks=[
self.b.current_playlist.load([
Track(name='a'), Track(name='b'), Track(name='c'),
Track(name='d'), Track(name='e'), Track(name='f')]))
Track(name='d'), Track(name='e'), Track(name='f'),
])
result = self.h.handle_request(u'move "1:3" "0"')
self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'b')
self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'c')
self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'a')
self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'e')
self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'b')
self.assertEqual(self.b.current_playlist.tracks[1].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'e')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
self.assert_(u'OK' in result)
def test_moveid(self):
self.b.current_playlist.load(Playlist(tracks=[
self.b.current_playlist.load([
Track(name='a'), Track(name='b'), Track(name='c'),
Track(name='d'), Track(name='e', id=137), Track(name='f')]))
Track(name='d'), Track(name='e', id=137), Track(name='f'),
])
result = self.h.handle_request(u'moveid "137" "2"')
self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'b')
self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'e')
self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'c')
self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'd')
self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[1].name, 'b')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'e')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
self.assert_(u'OK' in result)
def test_playlist_returns_same_as_playlistinfo(self):
@ -715,23 +719,26 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
self.assert_(u'ACK [0@0] {} Not implemented' in result)
def test_playlistfind_by_filename(self):
result = self.h.handle_request(u'playlistfind "filename" "file:///dev/null"')
result = self.h.handle_request(
u'playlistfind "filename" "file:///dev/null"')
self.assert_(u'OK' in result)
def test_playlistfind_by_filename_without_quotes(self):
result = self.h.handle_request(u'playlistfind filename "file:///dev/null"')
result = self.h.handle_request(
u'playlistfind filename "file:///dev/null"')
self.assert_(u'OK' in result)
def test_playlistfind_by_filename_in_current_playlist(self):
self.b.current_playlist.playlist = Playlist(tracks=[
self.b.current_playlist.load([
Track(uri='file:///exists')])
result = self.h.handle_request(u'playlistfind filename "file:///exists"')
result = self.h.handle_request(
u'playlistfind filename "file:///exists"')
self.assert_(u'file: file:///exists' in result)
self.assert_(u'OK' in result)
def test_playlistid_without_songid(self):
self.b.current_playlist.load(Playlist(
tracks=[Track(name='a', id=33), Track(name='b', id=38)]))
self.b.current_playlist.load(
[Track(name='a', id=33), Track(name='b', id=38)])
result = self.h.handle_request(u'playlistid')
self.assert_(u'Title: a' in result)
self.assert_(u'Id: 33' in result)
@ -740,8 +747,8 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
self.assert_(u'OK' in result)
def test_playlistid_with_songid(self):
self.b.current_playlist.load(Playlist(
tracks=[Track(name='a', id=33), Track(name='b', id=38)]))
self.b.current_playlist.load(
[Track(name='a', id=33), Track(name='b', id=38)])
result = self.h.handle_request(u'playlistid "38"')
self.assert_(u'Title: a' not in result)
self.assert_(u'Id: 33' not in result)
@ -750,8 +757,8 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
self.assert_(u'OK' in result)
def test_playlistid_with_not_existing_songid_fails(self):
self.b.current_playlist.load(Playlist(
tracks=[Track(name='a', id=33), Track(name='b', id=38)]))
self.b.current_playlist.load(
[Track(name='a', id=33), Track(name='b', id=38)])
result = self.h.handle_request(u'playlistid "25"')
self.assertEqual(result[0], u'ACK [50@0] {playlistid} No such song')
@ -785,8 +792,8 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
self.assert_(u'ACK [0@0] {} Not implemented' in result)
def test_plchanges(self):
self.b.current_playlist.load(Playlist(
tracks=[Track(name='a'), Track(name='b'), Track(name='c')]))
self.b.current_playlist.load(
[Track(name='a'), Track(name='b'), Track(name='c')])
result = self.h.handle_request(u'plchanges "0"')
self.assert_(u'Title: a' in result)
self.assert_(u'Title: b' in result)
@ -794,8 +801,8 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
self.assert_(u'OK' in result)
def test_plchangesposid(self):
self.b.current_playlist.load(Playlist(
tracks=[Track(id=11), Track(id=12), Track(id=13)]))
self.b.current_playlist.load(
[Track(id=11), Track(id=12), Track(id=13)])
result = self.h.handle_request(u'plchangesposid "0"')
self.assert_(u'cpos: 0' in result)
self.assert_(u'Id: 11' in result)
@ -806,64 +813,69 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
self.assert_(u'OK' in result)
def test_shuffle_without_range(self):
self.b.current_playlist.load(Playlist(tracks=[
self.b.current_playlist.load([
Track(name='a'), Track(name='b'), Track(name='c'),
Track(name='d'), Track(name='e'), Track(name='f')]))
Track(name='d'), Track(name='e'), Track(name='f'),
])
self.assertEqual(self.b.current_playlist.version, 1)
result = self.h.handle_request(u'shuffle')
self.assertEqual(self.b.current_playlist.version, 2)
self.assert_(u'OK' in result)
def test_shuffle_with_open_range(self):
self.b.current_playlist.load(Playlist(tracks=[
self.b.current_playlist.load([
Track(name='a'), Track(name='b'), Track(name='c'),
Track(name='d'), Track(name='e'), Track(name='f')]))
Track(name='d'), Track(name='e'), Track(name='f'),
])
self.assertEqual(self.b.current_playlist.version, 1)
result = self.h.handle_request(u'shuffle "4:"')
self.assertEqual(self.b.current_playlist.version, 2)
self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'b')
self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'c')
self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[1].name, 'b')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
self.assert_(u'OK' in result)
def test_shuffle_with_closed_range(self):
self.b.current_playlist.load(Playlist(tracks=[
self.b.current_playlist.load([
Track(name='a'), Track(name='b'), Track(name='c'),
Track(name='d'), Track(name='e'), Track(name='f')]))
Track(name='d'), Track(name='e'), Track(name='f'),
])
self.assertEqual(self.b.current_playlist.version, 1)
result = self.h.handle_request(u'shuffle "1:3"')
self.assertEqual(self.b.current_playlist.version, 2)
self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'e')
self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'e')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
self.assert_(u'OK' in result)
def test_swap(self):
self.b.current_playlist.load(Playlist(tracks=[
self.b.current_playlist.load([
Track(name='a'), Track(name='b'), Track(name='c'),
Track(name='d'), Track(name='e'), Track(name='f')]))
Track(name='d'), Track(name='e'), Track(name='f'),
])
result = self.h.handle_request(u'swap "1" "4"')
self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'e')
self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'c')
self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'b')
self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[1].name, 'e')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'b')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
self.assert_(u'OK' in result)
def test_swapid(self):
self.b.current_playlist.load(Playlist(tracks=[
self.b.current_playlist.load([
Track(name='a'), Track(name='b', id=13), Track(name='c'),
Track(name='d'), Track(name='e', id=29), Track(name='f')]))
Track(name='d'), Track(name='e', id=29), Track(name='f'),
])
result = self.h.handle_request(u'swapid "13" "29"')
self.assertEqual(self.b.current_playlist.playlist.tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.playlist.tracks[1].name, 'e')
self.assertEqual(self.b.current_playlist.playlist.tracks[2].name, 'c')
self.assertEqual(self.b.current_playlist.playlist.tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.playlist.tracks[4].name, 'b')
self.assertEqual(self.b.current_playlist.playlist.tracks[5].name, 'f')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[1].name, 'e')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'b')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f')
self.assert_(u'OK' in result)