From 4ba30f80e49f5c134baff3cff2ec1c4a322e59f1 Mon Sep 17 00:00:00 2001 From: Stein Magnus Jodal Date: Tue, 29 Jun 2010 23:53:52 +0200 Subject: [PATCH] CurrentPlaylistController.load() takes a list of tracks instead of a Playlist object --- docs/changes.rst | 7 + mopidy/backends/__init__.py | 58 ++++---- mopidy/mpd/frontend.py | 43 +++--- tests/backends/base.py | 115 +++++++-------- tests/mpd/frontend_test.py | 286 +++++++++++++++++++----------------- 5 files changed, 259 insertions(+), 250 deletions(-) diff --git a/docs/changes.rst b/docs/changes.rst index bc28d4b8..267df472 100644 --- a/docs/changes.rst +++ b/docs/changes.rst @@ -25,6 +25,13 @@ We got an updated :doc:`release 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) ==================== diff --git a/mopidy/backends/__init__.py b/mopidy/backends/__init__.py index 9b08250b..3983d94a 100644 --- a/mopidy/backends/__init__.py +++ b/mopidy/backends/__init__.py @@ -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 diff --git a/mopidy/mpd/frontend.py b/mopidy/mpd/frontend.py index f80c4e2b..3259306e 100644 --- a/mopidy/mpd/frontend.py +++ b/mopidy/mpd/frontend.py @@ -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-?\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[^"]+)" "(?P[^"]+)"$') 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\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\d+)" "(?P\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[^"]+)" "(?P[^"]+)"$') def _stored_playlist_playlistadd(self, name, uri): diff --git a/tests/backends/base.py b/tests/backends/base.py index 129ac4ff..6ecdb608 100644 --- a/tests/backends/base.py +++ b/tests/backends/base.py @@ -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) diff --git a/tests/mpd/frontend_test.py b/tests/mpd/frontend_test.py index a6faab5d..312986f7 100644 --- a/tests/mpd/frontend_test.py +++ b/tests/mpd/frontend_test.py @@ -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)