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

Update MPD/current_playlist

Browse Source
This commit is contained in:
Stein Magnus Jodal 2011-03-19 17:46:22 +01:00
parent 462f9d3afb
commit 0d57a74cb3
2 changed files with 153 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
mopidy/frontends/mpd/protocol/current_playlist.py
View File

@ -19,9 +19,9 @@ def add(frontend, uri):
""" """
if not uri: if not uri:
return return
for handler_prefix in frontend.backend.uri_handlers: for handler_prefix in frontend.backend.uri_handlers.get():
if uri.startswith(handler_prefix): if uri.startswith(handler_prefix):
track = frontend.backend.library.lookup(uri) track = frontend.backend.library.lookup(uri).get()
if track is not None: if track is not None:
frontend.backend.current_playlist.add(track) frontend.backend.current_playlist.add(track)
return return
@ -51,13 +51,14 @@ def addid(frontend, uri, songpos=None):
raise MpdNoExistError(u'No such song', command=u'addid') raise MpdNoExistError(u'No such song', command=u'addid')
if songpos is not None: if songpos is not None:
songpos = int(songpos) songpos = int(songpos)
track = frontend.backend.library.lookup(uri) track = frontend.backend.library.lookup(uri).get()
if track is None: if track is None:
raise MpdNoExistError(u'No such song', command=u'addid') raise MpdNoExistError(u'No such song', command=u'addid')
if songpos and songpos > len(frontend.backend.current_playlist.tracks): if songpos and songpos > len(
frontend.backend.current_playlist.tracks.get()):
raise MpdArgError(u'Bad song index', command=u'addid') raise MpdArgError(u'Bad song index', command=u'addid')
cp_track = frontend.backend.current_playlist.add(track, cp_track = frontend.backend.current_playlist.add(track,
at_position=songpos) at_position=songpos).get()
return ('Id', cp_track[0]) return ('Id', cp_track[0])
@handle_pattern(r'^delete "(?P<start>\d+):(?P<end>\d+)*"$') @handle_pattern(r'^delete "(?P<start>\d+):(?P<end>\d+)*"$')
@ -73,8 +74,8 @@ def delete_range(frontend, start, end=None):
if end is not None: if end is not None:
end = int(end) end = int(end)
else: else:
end = len(frontend.backend.current_playlist.tracks) end = len(frontend.backend.current_playlist.tracks.get())
cp_tracks = frontend.backend.current_playlist.cp_tracks[start:end] cp_tracks = frontend.backend.current_playlist.cp_tracks.get()[start:end]
if not cp_tracks: if not cp_tracks:
raise MpdArgError(u'Bad song index', command=u'delete') raise MpdArgError(u'Bad song index', command=u'delete')
for (cpid, _) in cp_tracks: for (cpid, _) in cp_tracks:
@ -85,7 +86,7 @@ def delete_songpos(frontend, songpos):
"""See :meth:`delete_range`""" """See :meth:`delete_range`"""
try: try:
songpos = int(songpos) songpos = int(songpos)
(cpid, _) = frontend.backend.current_playlist.cp_tracks[songpos] (cpid, _) = frontend.backend.current_playlist.cp_tracks.get()[songpos]
frontend.backend.current_playlist.remove(cpid=cpid) frontend.backend.current_playlist.remove(cpid=cpid)
except IndexError: except IndexError:
raise MpdArgError(u'Bad song index', command=u'delete') raise MpdArgError(u'Bad song index', command=u'delete')
@ -101,9 +102,9 @@ def deleteid(frontend, cpid):
""" """
try: try:
cpid = int(cpid) cpid = int(cpid)
if frontend.backend.playback.current_cpid == cpid: if frontend.backend.playback.current_cpid.get() == cpid:
frontend.backend.playback.next() frontend.backend.playback.next()
return frontend.backend.current_playlist.remove(cpid=cpid) return frontend.backend.current_playlist.remove(cpid=cpid).get()
except LookupError: except LookupError:
raise MpdNoExistError(u'No such song', command=u'deleteid') raise MpdNoExistError(u'No such song', command=u'deleteid')
@ -129,7 +130,7 @@ def move_range(frontend, start, to, end=None):
``TO`` in the playlist. ``TO`` in the playlist.
""" """
if end is None: if end is None:
end = len(frontend.backend.current_playlist.tracks) end = len(frontend.backend.current_playlist.tracks.get())
start = int(start) start = int(start)
end = int(end) end = int(end)
to = int(to) to = int(to)
@ -155,8 +156,9 @@ def moveid(frontend, cpid, to):
""" """
cpid = int(cpid) cpid = int(cpid)
to = int(to) to = int(to)
cp_track = frontend.backend.current_playlist.get(cpid=cpid) cp_track = frontend.backend.current_playlist.get(cpid=cpid).get()
position = frontend.backend.current_playlist.cp_tracks.index(cp_track) position = frontend.backend.current_playlist.cp_tracks.get().index(
cp_track)
frontend.backend.current_playlist.move(position, position + 1, to) frontend.backend.current_playlist.move(position, position + 1, to)
@handle_pattern(r'^playlist$') @handle_pattern(r'^playlist$')
@ -190,9 +192,9 @@ def playlistfind(frontend, tag, needle):
""" """
if tag == 'filename': if tag == 'filename':
try: try:
cp_track = frontend.backend.current_playlist.get(uri=needle) cp_track = frontend.backend.current_playlist.get(uri=needle).get()
(cpid, track) = cp_track (cpid, track) = cp_track
position = frontend.backend.current_playlist.cp_tracks.index( position = frontend.backend.current_playlist.cp_tracks.get().index(
cp_track) cp_track)
return track.mpd_format(cpid=cpid, position=position) return track.mpd_format(cpid=cpid, position=position)
except LookupError: except LookupError:
@ -212,16 +214,17 @@ def playlistid(frontend, cpid=None):
if cpid is not None: if cpid is not None:
try: try:
cpid = int(cpid) cpid = int(cpid)
cp_track = frontend.backend.current_playlist.get(cpid=cpid) cp_track = frontend.backend.current_playlist.get(cpid=cpid).get()
position = frontend.backend.current_playlist.cp_tracks.index( position = frontend.backend.current_playlist.cp_tracks.get().index(
cp_track) cp_track)
return cp_track[1].mpd_format(position=position, cpid=cpid) return cp_track[1].mpd_format(position=position, cpid=cpid)
except LookupError: except LookupError:
raise MpdNoExistError(u'No such song', command=u'playlistid') raise MpdNoExistError(u'No such song', command=u'playlistid')
else: else:
cpids = [ct[0] for ct in frontend.backend.current_playlist.cp_tracks] cpids = [ct[0] for ct in
return tracks_to_mpd_format(frontend.backend.current_playlist.tracks, frontend.backend.current_playlist.cp_tracks.get()]
cpids=cpids) return tracks_to_mpd_format(
frontend.backend.current_playlist.tracks.get(), cpids=cpids)
@handle_pattern(r'^playlistinfo$') @handle_pattern(r'^playlistinfo$')
@handle_pattern(r'^playlistinfo "(?P<songpos>-?\d+)"$') @handle_pattern(r'^playlistinfo "(?P<songpos>-?\d+)"$')
@ -251,21 +254,26 @@ def playlistinfo(frontend, songpos=None,
end = songpos + 1 end = songpos + 1
if start == -1: if start == -1:
end = None end = None
cpids = [ct[0] for ct in frontend.backend.current_playlist.cp_tracks] cpids = [ct[0] for ct in
return tracks_to_mpd_format(frontend.backend.current_playlist.tracks, frontend.backend.current_playlist.cp_tracks.get()]
return tracks_to_mpd_format(
frontend.backend.current_playlist.tracks.get(),
start, end, cpids=cpids) start, end, cpids=cpids)
else: else:
if start is None: if start is None:
start = 0 start = 0
start = int(start) start = int(start)
if not (0 <= start <= len(frontend.backend.current_playlist.tracks)): if not (0 <= start <= len(
frontend.backend.current_playlist.tracks.get())):
raise MpdArgError(u'Bad song index', command=u'playlistinfo') raise MpdArgError(u'Bad song index', command=u'playlistinfo')
if end is not None: if end is not None:
end = int(end) end = int(end)
if end > len(frontend.backend.current_playlist.tracks): if end > len(frontend.backend.current_playlist.tracks.get()):
end = None end = None
cpids = [ct[0] for ct in frontend.backend.current_playlist.cp_tracks] cpids = [ct[0] for ct in
return tracks_to_mpd_format(frontend.backend.current_playlist.tracks, frontend.backend.current_playlist.cp_tracks.get()]
return tracks_to_mpd_format(
frontend.backend.current_playlist.tracks.get(),
start, end, cpids=cpids) start, end, cpids=cpids)
@handle_pattern(r'^playlistsearch "(?P<tag>[^"]+)" "(?P<needle>[^"]+)"$') @handle_pattern(r'^playlistsearch "(?P<tag>[^"]+)" "(?P<needle>[^"]+)"$')
@ -305,9 +313,10 @@ def plchanges(frontend, version):
""" """
# XXX Naive implementation that returns all tracks as changed # XXX Naive implementation that returns all tracks as changed
if int(version) < frontend.backend.current_playlist.version: if int(version) < frontend.backend.current_playlist.version:
cpids = [ct[0] for ct in frontend.backend.current_playlist.cp_tracks] cpids = [ct[0] for ct in
return tracks_to_mpd_format(frontend.backend.current_playlist.tracks, frontend.backend.current_playlist.cp_tracks.get()]
cpids=cpids) return tracks_to_mpd_format(
frontend.backend.current_playlist.tracks.get(), cpids=cpids)
@handle_pattern(r'^plchangesposid "(?P<version>\d+)"$') @handle_pattern(r'^plchangesposid "(?P<version>\d+)"$')
def plchangesposid(frontend, version): def plchangesposid(frontend, version):
@ -324,10 +333,10 @@ def plchangesposid(frontend, version):
``playlistlength`` returned by status command. ``playlistlength`` returned by status command.
""" """
# XXX Naive implementation that returns all tracks as changed # XXX Naive implementation that returns all tracks as changed
if int(version) != frontend.backend.current_playlist.version: if int(version) != frontend.backend.current_playlist.version.get():
result = [] result = []
for (position, (cpid, _)) in enumerate( for (position, (cpid, _)) in enumerate(
frontend.backend.current_playlist.cp_tracks): frontend.backend.current_playlist.cp_tracks.get()):
result.append((u'cpos', position)) result.append((u'cpos', position))
result.append((u'Id', cpid)) result.append((u'Id', cpid))
return result return result
@ -360,7 +369,7 @@ def swap(frontend, songpos1, songpos2):
""" """
songpos1 = int(songpos1) songpos1 = int(songpos1)
songpos2 = int(songpos2) songpos2 = int(songpos2)
tracks = frontend.backend.current_playlist.tracks tracks = frontend.backend.current_playlist.tracks.get()
song1 = tracks[songpos1] song1 = tracks[songpos1]
song2 = tracks[songpos2] song2 = tracks[songpos2]
del tracks[songpos1] del tracks[songpos1]
@ -381,8 +390,9 @@ def swapid(frontend, cpid1, cpid2):
""" """
cpid1 = int(cpid1) cpid1 = int(cpid1)
cpid2 = int(cpid2) cpid2 = int(cpid2)
cp_track1 = frontend.backend.current_playlist.get(cpid=cpid1) cp_track1 = frontend.backend.current_playlist.get(cpid=cpid1).get()
cp_track2 = frontend.backend.current_playlist.get(cpid=cpid2) cp_track2 = frontend.backend.current_playlist.get(cpid=cpid2).get()
position1 = frontend.backend.current_playlist.cp_tracks.index(cp_track1) cp_tracks = frontend.backend.current_playlist.cp_tracks.get()
position2 = frontend.backend.current_playlist.cp_tracks.index(cp_track2) position1 = cp_tracks.index(cp_track1)
position2 = cp_tracks.index(cp_track2)
swap(frontend, position1, position2) swap(frontend, position1, position2)

206
tests/frontends/mpd/current_playlist_test.py
View File

@ -2,31 +2,28 @@ import unittest
from mopidy.backends.dummy import DummyBackend from mopidy.backends.dummy import DummyBackend
from mopidy.frontends.mpd import dispatcher from mopidy.frontends.mpd import dispatcher
from mopidy.mixers.dummy import DummyMixer
from mopidy.models import Track from mopidy.models import Track
class CurrentPlaylistHandlerTest(unittest.TestCase): class CurrentPlaylistHandlerTest(unittest.TestCase):
def setUp(self): def setUp(self):
self.b = DummyBackend(mixer_class=DummyMixer) self.b = DummyBackend.start().proxy()
self.h = dispatcher.MpdDispatcher(backend=self.b) self.h = dispatcher.MpdDispatcher()
def tearDown(self):
self.b.stop().get()
def test_add(self): def test_add(self):
needle = Track(uri='dummy://foo') needle = Track(uri='dummy://foo')
self.b.library.provider._library = [Track(), Track(), needle, Track()] self.b.library.provider.dummy_library = [
Track(), Track(), needle, Track()]
self.b.current_playlist.append( self.b.current_playlist.append(
[Track(), Track(), Track(), Track(), Track()]) [Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
result = self.h.handle_request(u'add "dummy://foo"') result = self.h.handle_request(u'add "dummy://foo"')
self.assertEqual(len(self.b.current_playlist.tracks), 6)
self.assertEqual(self.b.current_playlist.tracks[5], needle)
self.assertEqual(len(result), 1) self.assertEqual(len(result), 1)
self.assert_(u'OK' in result) self.assertEqual(result[0], u'OK')
self.assertEqual(len(self.b.current_playlist.tracks.get()), 6)
def test_add_with_uri_not_found_in_library_should_not_call_lookup(self): self.assertEqual(self.b.current_playlist.tracks.get()[5], needle)
self.b.library.lookup = lambda uri: self.fail("Shouldn't run")
result = self.h.handle_request(u'add "foo"')
self.assertEqual(result[0],
u'ACK [50@0] {add} directory or file not found')
def test_add_with_uri_not_found_in_library_should_ack(self): def test_add_with_uri_not_found_in_library_should_ack(self):
result = self.h.handle_request(u'add "dummy://foo"') result = self.h.handle_request(u'add "dummy://foo"')
@ -40,41 +37,43 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
def test_addid_without_songpos(self): def test_addid_without_songpos(self):
needle = Track(uri='dummy://foo') needle = Track(uri='dummy://foo')
self.b.library.provider._library = [Track(), Track(), needle, Track()] self.b.library.provider.dummy_library = [
Track(), Track(), needle, Track()]
self.b.current_playlist.append( self.b.current_playlist.append(
[Track(), Track(), Track(), Track(), Track()]) [Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
result = self.h.handle_request(u'addid "dummy://foo"') result = self.h.handle_request(u'addid "dummy://foo"')
self.assertEqual(len(self.b.current_playlist.tracks), 6) self.assertEqual(len(self.b.current_playlist.tracks.get()), 6)
self.assertEqual(self.b.current_playlist.tracks[5], needle) self.assertEqual(self.b.current_playlist.tracks.get()[5], needle)
self.assert_(u'Id: %d' % self.b.current_playlist.cp_tracks[5][0] self.assert_(u'Id: %d' % self.b.current_playlist.cp_tracks.get()[5][0]
in result) in result)
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_addid_with_empty_uri_does_not_lookup_and_acks(self): def test_addid_with_empty_uri_acks(self):
self.b.library.lookup = lambda uri: self.fail("Shouldn't run")
result = self.h.handle_request(u'addid ""') result = self.h.handle_request(u'addid ""')
self.assertEqual(result[0], u'ACK [50@0] {addid} No such song') self.assertEqual(result[0], u'ACK [50@0] {addid} No such song')
def test_addid_with_songpos(self): def test_addid_with_songpos(self):
needle = Track(uri='dummy://foo') needle = Track(uri='dummy://foo')
self.b.library.provider._library = [Track(), Track(), needle, Track()] self.b.library.provider.dummy_library = [
Track(), Track(), needle, Track()]
self.b.current_playlist.append( self.b.current_playlist.append(
[Track(), Track(), Track(), Track(), Track()]) [Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
result = self.h.handle_request(u'addid "dummy://foo" "3"') result = self.h.handle_request(u'addid "dummy://foo" "3"')
self.assertEqual(len(self.b.current_playlist.tracks), 6) self.assertEqual(len(self.b.current_playlist.tracks.get()), 6)
self.assertEqual(self.b.current_playlist.tracks[3], needle) self.assertEqual(self.b.current_playlist.tracks.get()[3], needle)
self.assert_(u'Id: %d' % self.b.current_playlist.cp_tracks[3][0] self.assert_(u'Id: %d' % self.b.current_playlist.cp_tracks.get()[3][0]
in result) in result)
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_addid_with_songpos_out_of_bounds_should_ack(self): def test_addid_with_songpos_out_of_bounds_should_ack(self):
needle = Track(uri='dummy://foo') needle = Track(uri='dummy://foo')
self.b.library.provider._library = [Track(), Track(), needle, Track()] self.b.library.provider.dummy_library = [
Track(), Track(), needle, Track()]
self.b.current_playlist.append( self.b.current_playlist.append(
[Track(), Track(), Track(), Track(), Track()]) [Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
result = self.h.handle_request(u'addid "dummy://foo" "6"') result = self.h.handle_request(u'addid "dummy://foo" "6"')
self.assertEqual(result[0], u'ACK [2@0] {addid} Bad song index') self.assertEqual(result[0], u'ACK [2@0] {addid} Bad song index')
@ -85,65 +84,65 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
def test_clear(self): def test_clear(self):
self.b.current_playlist.append( self.b.current_playlist.append(
[Track(), Track(), Track(), Track(), Track()]) [Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
result = self.h.handle_request(u'clear') result = self.h.handle_request(u'clear')
self.assertEqual(len(self.b.current_playlist.tracks), 0) self.assertEqual(len(self.b.current_playlist.tracks.get()), 0)
self.assertEqual(self.b.playback.current_track, None) self.assertEqual(self.b.playback.current_track.get(), None)
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_delete_songpos(self): def test_delete_songpos(self):
self.b.current_playlist.append( self.b.current_playlist.append(
[Track(), Track(), Track(), Track(), Track()]) [Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
result = self.h.handle_request(u'delete "%d"' % result = self.h.handle_request(u'delete "%d"' %
self.b.current_playlist.cp_tracks[2][0]) self.b.current_playlist.cp_tracks.get()[2][0])
self.assertEqual(len(self.b.current_playlist.tracks), 4) self.assertEqual(len(self.b.current_playlist.tracks.get()), 4)
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_delete_songpos_out_of_bounds(self): def test_delete_songpos_out_of_bounds(self):
self.b.current_playlist.append( self.b.current_playlist.append(
[Track(), Track(), Track(), Track(), Track()]) [Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
result = self.h.handle_request(u'delete "5"') result = self.h.handle_request(u'delete "5"')
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
self.assertEqual(result[0], u'ACK [2@0] {delete} Bad song index') self.assertEqual(result[0], u'ACK [2@0] {delete} Bad song index')
def test_delete_open_range(self): def test_delete_open_range(self):
self.b.current_playlist.append( self.b.current_playlist.append(
[Track(), Track(), Track(), Track(), Track()]) [Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
result = self.h.handle_request(u'delete "1:"') result = self.h.handle_request(u'delete "1:"')
self.assertEqual(len(self.b.current_playlist.tracks), 1) self.assertEqual(len(self.b.current_playlist.tracks.get()), 1)
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_delete_closed_range(self): def test_delete_closed_range(self):
self.b.current_playlist.append( self.b.current_playlist.append(
[Track(), Track(), Track(), Track(), Track()]) [Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
result = self.h.handle_request(u'delete "1:3"') result = self.h.handle_request(u'delete "1:3"')
self.assertEqual(len(self.b.current_playlist.tracks), 3) self.assertEqual(len(self.b.current_playlist.tracks.get()), 3)
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_delete_range_out_of_bounds(self): def test_delete_range_out_of_bounds(self):
self.b.current_playlist.append( self.b.current_playlist.append(
[Track(), Track(), Track(), Track(), Track()]) [Track(), Track(), Track(), Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
result = self.h.handle_request(u'delete "5:7"') result = self.h.handle_request(u'delete "5:7"')
self.assertEqual(len(self.b.current_playlist.tracks), 5) self.assertEqual(len(self.b.current_playlist.tracks.get()), 5)
self.assertEqual(result[0], u'ACK [2@0] {delete} Bad song index') self.assertEqual(result[0], u'ACK [2@0] {delete} Bad song index')
def test_deleteid(self): def test_deleteid(self):
self.b.current_playlist.append([Track(), Track()]) self.b.current_playlist.append([Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 2) self.assertEqual(len(self.b.current_playlist.tracks.get()), 2)
result = self.h.handle_request(u'deleteid "1"') result = self.h.handle_request(u'deleteid "1"')
self.assertEqual(len(self.b.current_playlist.tracks), 1) self.assertEqual(len(self.b.current_playlist.tracks.get()), 1)
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_deleteid_does_not_exist(self): def test_deleteid_does_not_exist(self):
self.b.current_playlist.append([Track(), Track()]) self.b.current_playlist.append([Track(), Track()])
self.assertEqual(len(self.b.current_playlist.tracks), 2) self.assertEqual(len(self.b.current_playlist.tracks.get()), 2)
result = self.h.handle_request(u'deleteid "12345"') result = self.h.handle_request(u'deleteid "12345"')
self.assertEqual(len(self.b.current_playlist.tracks), 2) self.assertEqual(len(self.b.current_playlist.tracks.get()), 2)
self.assertEqual(result[0], u'ACK [50@0] {deleteid} No such song') self.assertEqual(result[0], u'ACK [50@0] {deleteid} No such song')
def test_move_songpos(self): def test_move_songpos(self):
@ -152,12 +151,13 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
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"') result = self.h.handle_request(u'move "1" "0"')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'b') tracks = self.b.current_playlist.tracks.get()
self.assertEqual(self.b.current_playlist.tracks[1].name, 'a') self.assertEqual(tracks[0].name, 'b')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'c') self.assertEqual(tracks[1].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd') self.assertEqual(tracks[2].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'e') self.assertEqual(tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f') self.assertEqual(tracks[4].name, 'e')
self.assertEqual(tracks[5].name, 'f')
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_move_open_range(self): def test_move_open_range(self):
@ -166,12 +166,13 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
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"') result = self.h.handle_request(u'move "2:" "0"')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'c') tracks = self.b.current_playlist.tracks.get()
self.assertEqual(self.b.current_playlist.tracks[1].name, 'd') self.assertEqual(tracks[0].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'e') self.assertEqual(tracks[1].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'f') self.assertEqual(tracks[2].name, 'e')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'a') self.assertEqual(tracks[3].name, 'f')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'b') self.assertEqual(tracks[4].name, 'a')
self.assertEqual(tracks[5].name, 'b')
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_move_closed_range(self): def test_move_closed_range(self):
@ -180,12 +181,13 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
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"') result = self.h.handle_request(u'move "1:3" "0"')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'b') tracks = self.b.current_playlist.tracks.get()
self.assertEqual(self.b.current_playlist.tracks[1].name, 'c') self.assertEqual(tracks[0].name, 'b')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'a') self.assertEqual(tracks[1].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd') self.assertEqual(tracks[2].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'e') self.assertEqual(tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f') self.assertEqual(tracks[4].name, 'e')
self.assertEqual(tracks[5].name, 'f')
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_moveid(self): def test_moveid(self):
@ -194,12 +196,13 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
Track(name='d'), Track(name='e'), Track(name='f'), Track(name='d'), Track(name='e'), Track(name='f'),
]) ])
result = self.h.handle_request(u'moveid "4" "2"') result = self.h.handle_request(u'moveid "4" "2"')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'a') tracks = self.b.current_playlist.tracks.get()
self.assertEqual(self.b.current_playlist.tracks[1].name, 'b') self.assertEqual(tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'e') self.assertEqual(tracks[1].name, 'b')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'c') self.assertEqual(tracks[2].name, 'e')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'd') self.assertEqual(tracks[3].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f') self.assertEqual(tracks[4].name, 'd')
self.assertEqual(tracks[5].name, 'f')
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_playlist_returns_same_as_playlistinfo(self): def test_playlist_returns_same_as_playlistinfo(self):
@ -361,14 +364,15 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
def test_plchangesposid(self): def test_plchangesposid(self):
self.b.current_playlist.append([Track(), Track(), Track()]) self.b.current_playlist.append([Track(), Track(), Track()])
result = self.h.handle_request(u'plchangesposid "0"') result = self.h.handle_request(u'plchangesposid "0"')
cp_tracks = self.b.current_playlist.cp_tracks.get()
self.assert_(u'cpos: 0' in result) self.assert_(u'cpos: 0' in result)
self.assert_(u'Id: %d' % self.b.current_playlist.cp_tracks[0][0] self.assert_(u'Id: %d' % cp_tracks[0][0]
in result) in result)
self.assert_(u'cpos: 2' in result) self.assert_(u'cpos: 2' in result)
self.assert_(u'Id: %d' % self.b.current_playlist.cp_tracks[1][0] self.assert_(u'Id: %d' % cp_tracks[1][0]
in result) in result)
self.assert_(u'cpos: 2' in result) self.assert_(u'cpos: 2' in result)
self.assert_(u'Id: %d' % self.b.current_playlist.cp_tracks[2][0] self.assert_(u'Id: %d' % cp_tracks[2][0]
in result) in result)
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
@ -377,9 +381,9 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
Track(name='a'), Track(name='b'), Track(name='c'), 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'),
]) ])
version = self.b.current_playlist.version version = self.b.current_playlist.version.get()
result = self.h.handle_request(u'shuffle') result = self.h.handle_request(u'shuffle')
self.assert_(version < self.b.current_playlist.version) self.assert_(version < self.b.current_playlist.version.get())
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_shuffle_with_open_range(self): def test_shuffle_with_open_range(self):
@ -387,13 +391,14 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
Track(name='a'), Track(name='b'), Track(name='c'), 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'),
]) ])
version = self.b.current_playlist.version version = self.b.current_playlist.version.get()
result = self.h.handle_request(u'shuffle "4:"') result = self.h.handle_request(u'shuffle "4:"')
self.assert_(version < self.b.current_playlist.version) self.assert_(version < self.b.current_playlist.version.get())
self.assertEqual(self.b.current_playlist.tracks[0].name, 'a') tracks = self.b.current_playlist.tracks.get()
self.assertEqual(self.b.current_playlist.tracks[1].name, 'b') self.assertEqual(tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'c') self.assertEqual(tracks[1].name, 'b')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd') self.assertEqual(tracks[2].name, 'c')
self.assertEqual(tracks[3].name, 'd')
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_shuffle_with_closed_range(self): def test_shuffle_with_closed_range(self):
@ -401,13 +406,14 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
Track(name='a'), Track(name='b'), Track(name='c'), 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'),
]) ])
version = self.b.current_playlist.version version = self.b.current_playlist.version.get()
result = self.h.handle_request(u'shuffle "1:3"') result = self.h.handle_request(u'shuffle "1:3"')
self.assert_(version < self.b.current_playlist.version) self.assert_(version < self.b.current_playlist.version.get())
self.assertEqual(self.b.current_playlist.tracks[0].name, 'a') tracks = self.b.current_playlist.tracks.get()
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd') self.assertEqual(tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'e') self.assertEqual(tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f') self.assertEqual(tracks[4].name, 'e')
self.assertEqual(tracks[5].name, 'f')
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_swap(self): def test_swap(self):
@ -416,12 +422,13 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
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"') result = self.h.handle_request(u'swap "1" "4"')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'a') tracks = self.b.current_playlist.tracks.get()
self.assertEqual(self.b.current_playlist.tracks[1].name, 'e') self.assertEqual(tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'c') self.assertEqual(tracks[1].name, 'e')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd') self.assertEqual(tracks[2].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'b') self.assertEqual(tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f') self.assertEqual(tracks[4].name, 'b')
self.assertEqual(tracks[5].name, 'f')
self.assert_(u'OK' in result) self.assert_(u'OK' in result)
def test_swapid(self): def test_swapid(self):
@ -430,10 +437,11 @@ class CurrentPlaylistHandlerTest(unittest.TestCase):
Track(name='d'), Track(name='e'), Track(name='f'), Track(name='d'), Track(name='e'), Track(name='f'),
]) ])
result = self.h.handle_request(u'swapid "1" "4"') result = self.h.handle_request(u'swapid "1" "4"')
self.assertEqual(self.b.current_playlist.tracks[0].name, 'a') tracks = self.b.current_playlist.tracks.get()
self.assertEqual(self.b.current_playlist.tracks[1].name, 'e') self.assertEqual(tracks[0].name, 'a')
self.assertEqual(self.b.current_playlist.tracks[2].name, 'c') self.assertEqual(tracks[1].name, 'e')
self.assertEqual(self.b.current_playlist.tracks[3].name, 'd') self.assertEqual(tracks[2].name, 'c')
self.assertEqual(self.b.current_playlist.tracks[4].name, 'b') self.assertEqual(tracks[3].name, 'd')
self.assertEqual(self.b.current_playlist.tracks[5].name, 'f') self.assertEqual(tracks[4].name, 'b')
self.assertEqual(tracks[5].name, 'f')
self.assert_(u'OK' in result) self.assert_(u'OK' in result)