diff --git a/tests/frontends/mpd/audio_output_test.py b/tests/frontends/mpd/audio_output_test.py index afa99d26..82d9e203 100644 --- a/tests/frontends/mpd/audio_output_test.py +++ b/tests/frontends/mpd/audio_output_test.py @@ -1,29 +1,29 @@ import unittest from mopidy.backends.dummy import DummyBackend -from mopidy.frontends.mpd import dispatcher +from mopidy.frontends.mpd.dispatcher import MpdDispatcher from mopidy.mixers.dummy import DummyMixer class AudioOutputHandlerTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_enableoutput(self): - result = self.h.handle_request(u'enableoutput "0"') + result = self.dispatcher.handle_request(u'enableoutput "0"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_disableoutput(self): - result = self.h.handle_request(u'disableoutput "0"') + result = self.dispatcher.handle_request(u'disableoutput "0"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_outputs(self): - result = self.h.handle_request(u'outputs') + result = self.dispatcher.handle_request(u'outputs') self.assert_(u'outputid: 0' in result) self.assert_(u'outputname: None' in result) self.assert_(u'outputenabled: 1' in result) diff --git a/tests/frontends/mpd/connection_test.py b/tests/frontends/mpd/connection_test.py index cf161a5a..e34265d4 100644 --- a/tests/frontends/mpd/connection_test.py +++ b/tests/frontends/mpd/connection_test.py @@ -2,47 +2,47 @@ import unittest from mopidy import settings from mopidy.backends.dummy import DummyBackend -from mopidy.frontends.mpd import dispatcher +from mopidy.frontends.mpd.dispatcher import MpdDispatcher from mopidy.mixers.dummy import DummyMixer class ConnectionHandlerTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() settings.runtime.clear() def test_close(self): - result = self.h.handle_request(u'close') + result = self.dispatcher.handle_request(u'close') self.assert_(u'OK' in result) def test_empty_request(self): - result = self.h.handle_request(u'') + result = self.dispatcher.handle_request(u'') self.assert_(u'OK' in result) def test_kill(self): - result = self.h.handle_request(u'kill') + result = self.dispatcher.handle_request(u'kill') self.assert_(u'OK' in result) def test_valid_password_is_accepted(self): settings.MPD_SERVER_PASSWORD = u'topsecret' - result = self.h.handle_request(u'password "topsecret"') + result = self.dispatcher.handle_request(u'password "topsecret"') self.assert_(u'OK' in result) def test_invalid_password_is_not_accepted(self): settings.MPD_SERVER_PASSWORD = u'topsecret' - result = self.h.handle_request(u'password "secret"') + result = self.dispatcher.handle_request(u'password "secret"') self.assert_(u'ACK [3@0] {password} incorrect password' in result) def test_any_password_is_not_accepted_when_password_check_turned_off(self): settings.MPD_SERVER_PASSWORD = None - result = self.h.handle_request(u'password "secret"') + result = self.dispatcher.handle_request(u'password "secret"') self.assert_(u'ACK [3@0] {password} incorrect password' in result) def test_ping(self): - result = self.h.handle_request(u'ping') + result = self.dispatcher.handle_request(u'ping') self.assert_(u'OK' in result) diff --git a/tests/frontends/mpd/current_playlist_test.py b/tests/frontends/mpd/current_playlist_test.py index eb113ed7..c7f47429 100644 --- a/tests/frontends/mpd/current_playlist_test.py +++ b/tests/frontends/mpd/current_playlist_test.py @@ -1,160 +1,160 @@ import unittest from mopidy.backends.dummy import DummyBackend -from mopidy.frontends.mpd import dispatcher +from mopidy.frontends.mpd.dispatcher import MpdDispatcher from mopidy.mixers.dummy import DummyMixer from mopidy.models import Track class CurrentPlaylistHandlerTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_add(self): needle = Track(uri='dummy://foo') - self.b.library.provider.dummy_library = [ + self.backend.library.provider.dummy_library = [ Track(), Track(), needle, Track()] - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) - result = self.h.handle_request(u'add "dummy://foo"') + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + result = self.dispatcher.handle_request(u'add "dummy://foo"') self.assertEqual(len(result), 1) self.assertEqual(result[0], u'OK') - self.assertEqual(len(self.b.current_playlist.tracks.get()), 6) - self.assertEqual(self.b.current_playlist.tracks.get()[5], needle) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 6) + self.assertEqual(self.backend.current_playlist.tracks.get()[5], needle) def test_add_with_uri_not_found_in_library_should_ack(self): - result = self.h.handle_request(u'add "dummy://foo"') + result = self.dispatcher.handle_request(u'add "dummy://foo"') self.assertEqual(result[0], u'ACK [50@0] {add} directory or file not found') def test_add_with_empty_uri_should_add_all_known_tracks_and_ok(self): - result = self.h.handle_request(u'add ""') + result = self.dispatcher.handle_request(u'add ""') # TODO check that we add all tracks (we currently don't) self.assert_(u'OK' in result) def test_addid_without_songpos(self): needle = Track(uri='dummy://foo') - self.b.library.provider.dummy_library = [ + self.backend.library.provider.dummy_library = [ Track(), Track(), needle, Track()] - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) - result = self.h.handle_request(u'addid "dummy://foo"') - self.assertEqual(len(self.b.current_playlist.tracks.get()), 6) - self.assertEqual(self.b.current_playlist.tracks.get()[5], needle) - self.assert_(u'Id: %d' % self.b.current_playlist.cp_tracks.get()[5][0] - in result) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + result = self.dispatcher.handle_request(u'addid "dummy://foo"') + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 6) + self.assertEqual(self.backend.current_playlist.tracks.get()[5], needle) + self.assert_(u'Id: %d' % + self.backend.current_playlist.cp_tracks.get()[5][0] in result) self.assert_(u'OK' in result) def test_addid_with_empty_uri_acks(self): - result = self.h.handle_request(u'addid ""') + result = self.dispatcher.handle_request(u'addid ""') self.assertEqual(result[0], u'ACK [50@0] {addid} No such song') def test_addid_with_songpos(self): needle = Track(uri='dummy://foo') - self.b.library.provider.dummy_library = [ + self.backend.library.provider.dummy_library = [ Track(), Track(), needle, Track()] - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) - result = self.h.handle_request(u'addid "dummy://foo" "3"') - self.assertEqual(len(self.b.current_playlist.tracks.get()), 6) - self.assertEqual(self.b.current_playlist.tracks.get()[3], needle) - self.assert_(u'Id: %d' % self.b.current_playlist.cp_tracks.get()[3][0] - in result) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + result = self.dispatcher.handle_request(u'addid "dummy://foo" "3"') + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 6) + self.assertEqual(self.backend.current_playlist.tracks.get()[3], needle) + self.assert_(u'Id: %d' % + self.backend.current_playlist.cp_tracks.get()[3][0] in result) self.assert_(u'OK' in result) def test_addid_with_songpos_out_of_bounds_should_ack(self): needle = Track(uri='dummy://foo') - self.b.library.provider.dummy_library = [ + self.backend.library.provider.dummy_library = [ Track(), Track(), needle, Track()] - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) - result = self.h.handle_request(u'addid "dummy://foo" "6"') + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + result = self.dispatcher.handle_request(u'addid "dummy://foo" "6"') self.assertEqual(result[0], u'ACK [2@0] {addid} Bad song index') def test_addid_with_uri_not_found_in_library_should_ack(self): - result = self.h.handle_request(u'addid "dummy://foo"') + result = self.dispatcher.handle_request(u'addid "dummy://foo"') self.assertEqual(result[0], u'ACK [50@0] {addid} No such song') def test_clear(self): - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) - result = self.h.handle_request(u'clear') - self.assertEqual(len(self.b.current_playlist.tracks.get()), 0) - self.assertEqual(self.b.playback.current_track.get(), None) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + result = self.dispatcher.handle_request(u'clear') + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 0) + self.assertEqual(self.backend.playback.current_track.get(), None) self.assert_(u'OK' in result) def test_delete_songpos(self): - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) - result = self.h.handle_request(u'delete "%d"' % - self.b.current_playlist.cp_tracks.get()[2][0]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 4) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + result = self.dispatcher.handle_request(u'delete "%d"' % + self.backend.current_playlist.cp_tracks.get()[2][0]) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 4) self.assert_(u'OK' in result) def test_delete_songpos_out_of_bounds(self): - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) - result = self.h.handle_request(u'delete "5"') - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + result = self.dispatcher.handle_request(u'delete "5"') + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) self.assertEqual(result[0], u'ACK [2@0] {delete} Bad song index') def test_delete_open_range(self): - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) - result = self.h.handle_request(u'delete "1:"') - self.assertEqual(len(self.b.current_playlist.tracks.get()), 1) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + result = self.dispatcher.handle_request(u'delete "1:"') + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 1) self.assert_(u'OK' in result) def test_delete_closed_range(self): - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) - result = self.h.handle_request(u'delete "1:3"') - self.assertEqual(len(self.b.current_playlist.tracks.get()), 3) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + result = self.dispatcher.handle_request(u'delete "1:3"') + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 3) self.assert_(u'OK' in result) def test_delete_range_out_of_bounds(self): - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) - result = self.h.handle_request(u'delete "5:7"') - self.assertEqual(len(self.b.current_playlist.tracks.get()), 5) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) + result = self.dispatcher.handle_request(u'delete "5:7"') + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 5) self.assertEqual(result[0], u'ACK [2@0] {delete} Bad song index') def test_deleteid(self): - self.b.current_playlist.append([Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 2) - result = self.h.handle_request(u'deleteid "1"') - self.assertEqual(len(self.b.current_playlist.tracks.get()), 1) + self.backend.current_playlist.append([Track(), Track()]) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 2) + result = self.dispatcher.handle_request(u'deleteid "1"') + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 1) self.assert_(u'OK' in result) def test_deleteid_does_not_exist(self): - self.b.current_playlist.append([Track(), Track()]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 2) - result = self.h.handle_request(u'deleteid "12345"') - self.assertEqual(len(self.b.current_playlist.tracks.get()), 2) + self.backend.current_playlist.append([Track(), Track()]) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 2) + result = self.dispatcher.handle_request(u'deleteid "12345"') + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 2) self.assertEqual(result[0], u'ACK [50@0] {deleteid} No such song') def test_move_songpos(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - result = self.h.handle_request(u'move "1" "0"') - tracks = self.b.current_playlist.tracks.get() + result = self.dispatcher.handle_request(u'move "1" "0"') + tracks = self.backend.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'b') self.assertEqual(tracks[1].name, 'a') self.assertEqual(tracks[2].name, 'c') @@ -164,12 +164,12 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_move_open_range(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - result = self.h.handle_request(u'move "2:" "0"') - tracks = self.b.current_playlist.tracks.get() + result = self.dispatcher.handle_request(u'move "2:" "0"') + tracks = self.backend.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'c') self.assertEqual(tracks[1].name, 'd') self.assertEqual(tracks[2].name, 'e') @@ -179,12 +179,12 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_move_closed_range(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - result = self.h.handle_request(u'move "1:3" "0"') - tracks = self.b.current_playlist.tracks.get() + result = self.dispatcher.handle_request(u'move "1:3" "0"') + tracks = self.backend.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'b') self.assertEqual(tracks[1].name, 'c') self.assertEqual(tracks[2].name, 'a') @@ -194,12 +194,12 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_moveid(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - result = self.h.handle_request(u'moveid "4" "2"') - tracks = self.b.current_playlist.tracks.get() + result = self.dispatcher.handle_request(u'moveid "4" "2"') + tracks = self.backend.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[1].name, 'b') self.assertEqual(tracks[2].name, 'e') @@ -209,30 +209,30 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_playlist_returns_same_as_playlistinfo(self): - playlist_result = self.h.handle_request(u'playlist') - playlistinfo_result = self.h.handle_request(u'playlistinfo') + playlist_result = self.dispatcher.handle_request(u'playlist') + playlistinfo_result = self.dispatcher.handle_request(u'playlistinfo') self.assertEqual(playlist_result, playlistinfo_result) def test_playlistfind(self): - result = self.h.handle_request(u'playlistfind "tag" "needle"') + result = self.dispatcher.handle_request(u'playlistfind "tag" "needle"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_playlistfind_by_filename_not_in_current_playlist(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'playlistfind "filename" "file:///dev/null"') self.assertEqual(len(result), 1) self.assert_(u'OK' in result) def test_playlistfind_by_filename_without_quotes(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'playlistfind filename "file:///dev/null"') self.assertEqual(len(result), 1) self.assert_(u'OK' in result) def test_playlistfind_by_filename_in_current_playlist(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(uri='file:///exists')]) - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'playlistfind filename "file:///exists"') self.assert_(u'file: file:///exists' in result) self.assert_(u'Id: 0' in result) @@ -240,15 +240,15 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_playlistid_without_songid(self): - self.b.current_playlist.append([Track(name='a'), Track(name='b')]) - result = self.h.handle_request(u'playlistid') + self.backend.current_playlist.append([Track(name='a'), Track(name='b')]) + result = self.dispatcher.handle_request(u'playlistid') self.assert_(u'Title: a' in result) self.assert_(u'Title: b' in result) self.assert_(u'OK' in result) def test_playlistid_with_songid(self): - self.b.current_playlist.append([Track(name='a'), Track(name='b')]) - result = self.h.handle_request(u'playlistid "1"') + self.backend.current_playlist.append([Track(name='a'), Track(name='b')]) + result = self.dispatcher.handle_request(u'playlistid "1"') self.assert_(u'Title: a' not in result) self.assert_(u'Id: 0' not in result) self.assert_(u'Title: b' in result) @@ -256,16 +256,16 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_playlistid_with_not_existing_songid_fails(self): - self.b.current_playlist.append([Track(name='a'), Track(name='b')]) - result = self.h.handle_request(u'playlistid "25"') + self.backend.current_playlist.append([Track(name='a'), Track(name='b')]) + result = self.dispatcher.handle_request(u'playlistid "25"') self.assertEqual(result[0], u'ACK [50@0] {playlistid} No such song') def test_playlistinfo_without_songpos_or_range(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - result = self.h.handle_request(u'playlistinfo') + result = self.dispatcher.handle_request(u'playlistinfo') self.assert_(u'Title: a' in result) self.assert_(u'Title: b' in result) self.assert_(u'Title: c' in result) @@ -275,11 +275,11 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_playlistinfo_with_songpos(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - result = self.h.handle_request(u'playlistinfo "4"') + result = self.dispatcher.handle_request(u'playlistinfo "4"') self.assert_(u'Title: a' not in result) self.assert_(u'Title: b' not in result) self.assert_(u'Title: c' not in result) @@ -289,16 +289,16 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_playlistinfo_with_negative_songpos_same_as_playlistinfo(self): - result1 = self.h.handle_request(u'playlistinfo "-1"') - result2 = self.h.handle_request(u'playlistinfo') + result1 = self.dispatcher.handle_request(u'playlistinfo "-1"') + result2 = self.dispatcher.handle_request(u'playlistinfo') self.assertEqual(result1, result2) def test_playlistinfo_with_open_range(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - result = self.h.handle_request(u'playlistinfo "2:"') + result = self.dispatcher.handle_request(u'playlistinfo "2:"') self.assert_(u'Title: a' not in result) self.assert_(u'Title: b' not in result) self.assert_(u'Title: c' in result) @@ -308,11 +308,11 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_playlistinfo_with_closed_range(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - result = self.h.handle_request(u'playlistinfo "2:4"') + result = self.dispatcher.handle_request(u'playlistinfo "2:4"') self.assert_(u'Title: a' not in result) self.assert_(u'Title: b' not in result) self.assert_(u'Title: c' in result) @@ -322,52 +322,53 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_playlistinfo_with_too_high_start_of_range_returns_arg_error(self): - result = self.h.handle_request(u'playlistinfo "10:20"') + result = self.dispatcher.handle_request(u'playlistinfo "10:20"') self.assert_(u'ACK [2@0] {playlistinfo} Bad song index' in result) def test_playlistinfo_with_too_high_end_of_range_returns_ok(self): - result = self.h.handle_request(u'playlistinfo "0:20"') + result = self.dispatcher.handle_request(u'playlistinfo "0:20"') self.assert_(u'OK' in result) def test_playlistsearch(self): - result = self.h.handle_request(u'playlistsearch "any" "needle"') + result = self.dispatcher.handle_request( + u'playlistsearch "any" "needle"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_playlistsearch_without_quotes(self): - result = self.h.handle_request(u'playlistsearch any "needle"') + result = self.dispatcher.handle_request(u'playlistsearch any "needle"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_plchanges(self): - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(name='a'), Track(name='b'), Track(name='c')]) - result = self.h.handle_request(u'plchanges "0"') + result = self.dispatcher.handle_request(u'plchanges "0"') self.assert_(u'Title: a' in result) self.assert_(u'Title: b' in result) self.assert_(u'Title: c' in result) self.assert_(u'OK' in result) def test_plchanges_with_minus_one_returns_entire_playlist(self): - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(name='a'), Track(name='b'), Track(name='c')]) - result = self.h.handle_request(u'plchanges "-1"') + result = self.dispatcher.handle_request(u'plchanges "-1"') self.assert_(u'Title: a' in result) self.assert_(u'Title: b' in result) self.assert_(u'Title: c' in result) self.assert_(u'OK' in result) def test_plchanges_without_quotes_works(self): - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(name='a'), Track(name='b'), Track(name='c')]) - result = self.h.handle_request(u'plchanges 0') + result = self.dispatcher.handle_request(u'plchanges 0') self.assert_(u'Title: a' in result) self.assert_(u'Title: b' in result) self.assert_(u'Title: c' in result) self.assert_(u'OK' in result) def test_plchangesposid(self): - self.b.current_playlist.append([Track(), Track(), Track()]) - result = self.h.handle_request(u'plchangesposid "0"') - cp_tracks = self.b.current_playlist.cp_tracks.get() + self.backend.current_playlist.append([Track(), Track(), Track()]) + result = self.dispatcher.handle_request(u'plchangesposid "0"') + cp_tracks = self.backend.current_playlist.cp_tracks.get() self.assert_(u'cpos: 0' in result) self.assert_(u'Id: %d' % cp_tracks[0][0] in result) @@ -380,24 +381,24 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_shuffle_without_range(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - version = self.b.current_playlist.version.get() - result = self.h.handle_request(u'shuffle') - self.assert_(version < self.b.current_playlist.version.get()) + version = self.backend.current_playlist.version.get() + result = self.dispatcher.handle_request(u'shuffle') + self.assert_(version < self.backend.current_playlist.version.get()) self.assert_(u'OK' in result) def test_shuffle_with_open_range(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - version = self.b.current_playlist.version.get() - result = self.h.handle_request(u'shuffle "4:"') - self.assert_(version < self.b.current_playlist.version.get()) - tracks = self.b.current_playlist.tracks.get() + version = self.backend.current_playlist.version.get() + result = self.dispatcher.handle_request(u'shuffle "4:"') + self.assert_(version < self.backend.current_playlist.version.get()) + tracks = self.backend.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[1].name, 'b') self.assertEqual(tracks[2].name, 'c') @@ -405,14 +406,14 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_shuffle_with_closed_range(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - version = self.b.current_playlist.version.get() - result = self.h.handle_request(u'shuffle "1:3"') - self.assert_(version < self.b.current_playlist.version.get()) - tracks = self.b.current_playlist.tracks.get() + version = self.backend.current_playlist.version.get() + result = self.dispatcher.handle_request(u'shuffle "1:3"') + self.assert_(version < self.backend.current_playlist.version.get()) + tracks = self.backend.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[3].name, 'd') self.assertEqual(tracks[4].name, 'e') @@ -420,12 +421,12 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_swap(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - result = self.h.handle_request(u'swap "1" "4"') - tracks = self.b.current_playlist.tracks.get() + result = self.dispatcher.handle_request(u'swap "1" "4"') + tracks = self.backend.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[1].name, 'e') self.assertEqual(tracks[2].name, 'c') @@ -435,12 +436,12 @@ class CurrentPlaylistHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_swapid(self): - self.b.current_playlist.append([ + self.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) - result = self.h.handle_request(u'swapid "1" "4"') - tracks = self.b.current_playlist.tracks.get() + result = self.dispatcher.handle_request(u'swapid "1" "4"') + tracks = self.backend.current_playlist.tracks.get() self.assertEqual(tracks[0].name, 'a') self.assertEqual(tracks[1].name, 'e') self.assertEqual(tracks[2].name, 'c') diff --git a/tests/frontends/mpd/dispatcher_test.py b/tests/frontends/mpd/dispatcher_test.py index 77e0ddf0..1d8efe64 100644 --- a/tests/frontends/mpd/dispatcher_test.py +++ b/tests/frontends/mpd/dispatcher_test.py @@ -1,19 +1,19 @@ import unittest from mopidy.backends.dummy import DummyBackend -from mopidy.frontends.mpd import dispatcher +from mopidy.frontends.mpd.dispatcher import MpdDispatcher from mopidy.frontends.mpd.exceptions import MpdAckError from mopidy.frontends.mpd.protocol import request_handlers, handle_pattern from mopidy.mixers.dummy import DummyMixer class MpdDispatcherTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_register_same_pattern_twice_fails(self): @@ -27,7 +27,7 @@ class MpdDispatcherTest(unittest.TestCase): def test_finding_handler_for_unknown_command_raises_exception(self): try: - self.h.find_handler('an_unknown_command with args') + self.dispatcher.find_handler('an_unknown_command with args') self.fail('Should raise exception') except MpdAckError as e: self.assertEqual(e.get_mpd_ack(), @@ -37,18 +37,18 @@ class MpdDispatcherTest(unittest.TestCase): expected_handler = lambda x: None request_handlers['known_command (?P.+)'] = \ expected_handler - (handler, kwargs) = self.h.find_handler('known_command an_arg') + (handler, kwargs) = self.dispatcher.find_handler('known_command an_arg') self.assertEqual(handler, expected_handler) self.assert_('arg1' in kwargs) self.assertEqual(kwargs['arg1'], 'an_arg') def test_handling_unknown_request_yields_error(self): - result = self.h.handle_request('an unhandled request') + result = self.dispatcher.handle_request('an unhandled request') self.assertEqual(result[0], u'ACK [5@0] {} unknown command "an"') def test_handling_known_request(self): expected = 'magic' request_handlers['known request'] = lambda x: expected - result = self.h.handle_request('known request') + result = self.dispatcher.handle_request('known request') self.assert_(u'OK' in result) self.assert_(expected in result) diff --git a/tests/frontends/mpd/music_db_test.py b/tests/frontends/mpd/music_db_test.py index fa5634be..3793db9e 100644 --- a/tests/frontends/mpd/music_db_test.py +++ b/tests/frontends/mpd/music_db_test.py @@ -1,390 +1,412 @@ import unittest from mopidy.backends.dummy import DummyBackend -from mopidy.frontends.mpd import dispatcher +from mopidy.frontends.mpd.dispatcher import MpdDispatcher from mopidy.mixers.dummy import DummyMixer class MusicDatabaseHandlerTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_count(self): - result = self.h.handle_request(u'count "tag" "needle"') + result = self.dispatcher.handle_request(u'count "tag" "needle"') self.assert_(u'songs: 0' in result) self.assert_(u'playtime: 0' in result) self.assert_(u'OK' in result) def test_findadd(self): - result = self.h.handle_request(u'findadd "album" "what"') + result = self.dispatcher.handle_request(u'findadd "album" "what"') self.assert_(u'OK' in result) def test_listall(self): - result = self.h.handle_request(u'listall "file:///dev/urandom"') + result = self.dispatcher.handle_request( + u'listall "file:///dev/urandom"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_listallinfo(self): - result = self.h.handle_request(u'listallinfo "file:///dev/urandom"') + result = self.dispatcher.handle_request( + u'listallinfo "file:///dev/urandom"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_lsinfo_without_path_returns_same_as_listplaylists(self): - lsinfo_result = self.h.handle_request(u'lsinfo') - listplaylists_result = self.h.handle_request(u'listplaylists') + lsinfo_result = self.dispatcher.handle_request(u'lsinfo') + listplaylists_result = self.dispatcher.handle_request(u'listplaylists') self.assertEqual(lsinfo_result, listplaylists_result) def test_lsinfo_with_empty_path_returns_same_as_listplaylists(self): - lsinfo_result = self.h.handle_request(u'lsinfo ""') - listplaylists_result = self.h.handle_request(u'listplaylists') + lsinfo_result = self.dispatcher.handle_request(u'lsinfo ""') + listplaylists_result = self.dispatcher.handle_request(u'listplaylists') self.assertEqual(lsinfo_result, listplaylists_result) def test_lsinfo_for_root_returns_same_as_listplaylists(self): - lsinfo_result = self.h.handle_request(u'lsinfo "/"') - listplaylists_result = self.h.handle_request(u'listplaylists') + lsinfo_result = self.dispatcher.handle_request(u'lsinfo "/"') + listplaylists_result = self.dispatcher.handle_request(u'listplaylists') self.assertEqual(lsinfo_result, listplaylists_result) def test_update_without_uri(self): - result = self.h.handle_request(u'update') + result = self.dispatcher.handle_request(u'update') self.assert_(u'OK' in result) self.assert_(u'updating_db: 0' in result) def test_update_with_uri(self): - result = self.h.handle_request(u'update "file:///dev/urandom"') + result = self.dispatcher.handle_request(u'update "file:///dev/urandom"') self.assert_(u'OK' in result) self.assert_(u'updating_db: 0' in result) def test_rescan_without_uri(self): - result = self.h.handle_request(u'rescan') + result = self.dispatcher.handle_request(u'rescan') self.assert_(u'OK' in result) self.assert_(u'updating_db: 0' in result) def test_rescan_with_uri(self): - result = self.h.handle_request(u'rescan "file:///dev/urandom"') + result = self.dispatcher.handle_request(u'rescan "file:///dev/urandom"') self.assert_(u'OK' in result) self.assert_(u'updating_db: 0' in result) class MusicDatabaseFindTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_find_album(self): - result = self.h.handle_request(u'find "album" "what"') + result = self.dispatcher.handle_request(u'find "album" "what"') self.assert_(u'OK' in result) def test_find_album_without_quotes(self): - result = self.h.handle_request(u'find album "what"') + result = self.dispatcher.handle_request(u'find album "what"') self.assert_(u'OK' in result) def test_find_artist(self): - result = self.h.handle_request(u'find "artist" "what"') + result = self.dispatcher.handle_request(u'find "artist" "what"') self.assert_(u'OK' in result) def test_find_artist_without_quotes(self): - result = self.h.handle_request(u'find artist "what"') + result = self.dispatcher.handle_request(u'find artist "what"') self.assert_(u'OK' in result) def test_find_title(self): - result = self.h.handle_request(u'find "title" "what"') + result = self.dispatcher.handle_request(u'find "title" "what"') self.assert_(u'OK' in result) def test_find_title_without_quotes(self): - result = self.h.handle_request(u'find title "what"') + result = self.dispatcher.handle_request(u'find title "what"') self.assert_(u'OK' in result) def test_find_date(self): - result = self.h.handle_request(u'find "date" "2002-01-01"') + result = self.dispatcher.handle_request(u'find "date" "2002-01-01"') self.assert_(u'OK' in result) def test_find_date_without_quotes(self): - result = self.h.handle_request(u'find date "2002-01-01"') + result = self.dispatcher.handle_request(u'find date "2002-01-01"') self.assert_(u'OK' in result) def test_find_date_with_capital_d_and_incomplete_date(self): - result = self.h.handle_request(u'find Date "2005"') + result = self.dispatcher.handle_request(u'find Date "2005"') self.assert_(u'OK' in result) def test_find_else_should_fail(self): - result = self.h.handle_request(u'find "somethingelse" "what"') + result = self.dispatcher.handle_request(u'find "somethingelse" "what"') self.assertEqual(result[0], u'ACK [2@0] {find} incorrect arguments') def test_find_album_and_artist(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'find album "album_what" artist "artist_what"') self.assert_(u'OK' in result) class MusicDatabaseListTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_list_foo_returns_ack(self): - result = self.h.handle_request(u'list "foo"') + result = self.dispatcher.handle_request(u'list "foo"') self.assertEqual(result[0], u'ACK [2@0] {list} incorrect arguments') ### Artist def test_list_artist_with_quotes(self): - result = self.h.handle_request(u'list "artist"') + result = self.dispatcher.handle_request(u'list "artist"') self.assert_(u'OK' in result) def test_list_artist_without_quotes(self): - result = self.h.handle_request(u'list artist') + result = self.dispatcher.handle_request(u'list artist') self.assert_(u'OK' in result) def test_list_artist_without_quotes_and_capitalized(self): - result = self.h.handle_request(u'list Artist') + result = self.dispatcher.handle_request(u'list Artist') self.assert_(u'OK' in result) def test_list_artist_with_query_of_one_token(self): - result = self.h.handle_request(u'list "artist" "anartist"') + result = self.dispatcher.handle_request(u'list "artist" "anartist"') self.assertEqual(result[0], u'ACK [2@0] {list} should be "Album" for 3 arguments') def test_list_artist_with_unknown_field_in_query_returns_ack(self): - result = self.h.handle_request(u'list "artist" "foo" "bar"') + result = self.dispatcher.handle_request(u'list "artist" "foo" "bar"') self.assertEqual(result[0], u'ACK [2@0] {list} not able to parse args') def test_list_artist_by_artist(self): - result = self.h.handle_request(u'list "artist" "artist" "anartist"') + result = self.dispatcher.handle_request( + u'list "artist" "artist" "anartist"') self.assert_(u'OK' in result) def test_list_artist_by_album(self): - result = self.h.handle_request(u'list "artist" "album" "analbum"') + result = self.dispatcher.handle_request( + u'list "artist" "album" "analbum"') self.assert_(u'OK' in result) def test_list_artist_by_full_date(self): - result = self.h.handle_request(u'list "artist" "date" "2001-01-01"') + result = self.dispatcher.handle_request( + u'list "artist" "date" "2001-01-01"') self.assert_(u'OK' in result) def test_list_artist_by_year(self): - result = self.h.handle_request(u'list "artist" "date" "2001"') + result = self.dispatcher.handle_request( + u'list "artist" "date" "2001"') self.assert_(u'OK' in result) def test_list_artist_by_genre(self): - result = self.h.handle_request(u'list "artist" "genre" "agenre"') + result = self.dispatcher.handle_request( + u'list "artist" "genre" "agenre"') self.assert_(u'OK' in result) def test_list_artist_by_artist_and_album(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'list "artist" "artist" "anartist" "album" "analbum"') self.assert_(u'OK' in result) ### Album def test_list_album_with_quotes(self): - result = self.h.handle_request(u'list "album"') + result = self.dispatcher.handle_request(u'list "album"') self.assert_(u'OK' in result) def test_list_album_without_quotes(self): - result = self.h.handle_request(u'list album') + result = self.dispatcher.handle_request(u'list album') self.assert_(u'OK' in result) def test_list_album_without_quotes_and_capitalized(self): - result = self.h.handle_request(u'list Album') + result = self.dispatcher.handle_request(u'list Album') self.assert_(u'OK' in result) def test_list_album_with_artist_name(self): - result = self.h.handle_request(u'list "album" "anartist"') + result = self.dispatcher.handle_request(u'list "album" "anartist"') self.assert_(u'OK' in result) def test_list_album_by_artist(self): - result = self.h.handle_request(u'list "album" "artist" "anartist"') + result = self.dispatcher.handle_request( + u'list "album" "artist" "anartist"') self.assert_(u'OK' in result) def test_list_album_by_album(self): - result = self.h.handle_request(u'list "album" "album" "analbum"') + result = self.dispatcher.handle_request( + u'list "album" "album" "analbum"') self.assert_(u'OK' in result) def test_list_album_by_full_date(self): - result = self.h.handle_request(u'list "album" "date" "2001-01-01"') + result = self.dispatcher.handle_request( + u'list "album" "date" "2001-01-01"') self.assert_(u'OK' in result) def test_list_album_by_year(self): - result = self.h.handle_request(u'list "album" "date" "2001"') + result = self.dispatcher.handle_request( + u'list "album" "date" "2001"') self.assert_(u'OK' in result) def test_list_album_by_genre(self): - result = self.h.handle_request(u'list "album" "genre" "agenre"') + result = self.dispatcher.handle_request( + u'list "album" "genre" "agenre"') self.assert_(u'OK' in result) def test_list_album_by_artist_and_album(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'list "album" "artist" "anartist" "album" "analbum"') self.assert_(u'OK' in result) ### Date def test_list_date_with_quotes(self): - result = self.h.handle_request(u'list "date"') + result = self.dispatcher.handle_request(u'list "date"') self.assert_(u'OK' in result) def test_list_date_without_quotes(self): - result = self.h.handle_request(u'list date') + result = self.dispatcher.handle_request(u'list date') self.assert_(u'OK' in result) def test_list_date_without_quotes_and_capitalized(self): - result = self.h.handle_request(u'list Date') + result = self.dispatcher.handle_request(u'list Date') self.assert_(u'OK' in result) def test_list_date_with_query_of_one_token(self): - result = self.h.handle_request(u'list "date" "anartist"') + result = self.dispatcher.handle_request(u'list "date" "anartist"') self.assertEqual(result[0], u'ACK [2@0] {list} should be "Album" for 3 arguments') def test_list_date_by_artist(self): - result = self.h.handle_request(u'list "date" "artist" "anartist"') + result = self.dispatcher.handle_request( + u'list "date" "artist" "anartist"') self.assert_(u'OK' in result) def test_list_date_by_album(self): - result = self.h.handle_request(u'list "date" "album" "analbum"') + result = self.dispatcher.handle_request( + u'list "date" "album" "analbum"') self.assert_(u'OK' in result) def test_list_date_by_full_date(self): - result = self.h.handle_request(u'list "date" "date" "2001-01-01"') + result = self.dispatcher.handle_request( + u'list "date" "date" "2001-01-01"') self.assert_(u'OK' in result) def test_list_date_by_year(self): - result = self.h.handle_request(u'list "date" "date" "2001"') + result = self.dispatcher.handle_request(u'list "date" "date" "2001"') self.assert_(u'OK' in result) def test_list_date_by_genre(self): - result = self.h.handle_request(u'list "date" "genre" "agenre"') + result = self.dispatcher.handle_request(u'list "date" "genre" "agenre"') self.assert_(u'OK' in result) def test_list_date_by_artist_and_album(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'list "date" "artist" "anartist" "album" "analbum"') self.assert_(u'OK' in result) ### Genre def test_list_genre_with_quotes(self): - result = self.h.handle_request(u'list "genre"') + result = self.dispatcher.handle_request(u'list "genre"') self.assert_(u'OK' in result) def test_list_genre_without_quotes(self): - result = self.h.handle_request(u'list genre') + result = self.dispatcher.handle_request(u'list genre') self.assert_(u'OK' in result) def test_list_genre_without_quotes_and_capitalized(self): - result = self.h.handle_request(u'list Genre') + result = self.dispatcher.handle_request(u'list Genre') self.assert_(u'OK' in result) def test_list_genre_with_query_of_one_token(self): - result = self.h.handle_request(u'list "genre" "anartist"') + result = self.dispatcher.handle_request(u'list "genre" "anartist"') self.assertEqual(result[0], u'ACK [2@0] {list} should be "Album" for 3 arguments') def test_list_genre_by_artist(self): - result = self.h.handle_request(u'list "genre" "artist" "anartist"') + result = self.dispatcher.handle_request( + u'list "genre" "artist" "anartist"') self.assert_(u'OK' in result) def test_list_genre_by_album(self): - result = self.h.handle_request(u'list "genre" "album" "analbum"') + result = self.dispatcher.handle_request( + u'list "genre" "album" "analbum"') self.assert_(u'OK' in result) def test_list_genre_by_full_date(self): - result = self.h.handle_request(u'list "genre" "date" "2001-01-01"') + result = self.dispatcher.handle_request( + u'list "genre" "date" "2001-01-01"') self.assert_(u'OK' in result) def test_list_genre_by_year(self): - result = self.h.handle_request(u'list "genre" "date" "2001"') + result = self.dispatcher.handle_request( + u'list "genre" "date" "2001"') self.assert_(u'OK' in result) def test_list_genre_by_genre(self): - result = self.h.handle_request(u'list "genre" "genre" "agenre"') + result = self.dispatcher.handle_request( + u'list "genre" "genre" "agenre"') self.assert_(u'OK' in result) def test_list_genre_by_artist_and_album(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'list "genre" "artist" "anartist" "album" "analbum"') self.assert_(u'OK' in result) class MusicDatabaseSearchTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_search_album(self): - result = self.h.handle_request(u'search "album" "analbum"') + result = self.dispatcher.handle_request(u'search "album" "analbum"') self.assert_(u'OK' in result) def test_search_album_without_quotes(self): - result = self.h.handle_request(u'search album "analbum"') + result = self.dispatcher.handle_request(u'search album "analbum"') self.assert_(u'OK' in result) def test_search_artist(self): - result = self.h.handle_request(u'search "artist" "anartist"') + result = self.dispatcher.handle_request(u'search "artist" "anartist"') self.assert_(u'OK' in result) def test_search_artist_without_quotes(self): - result = self.h.handle_request(u'search artist "anartist"') + result = self.dispatcher.handle_request(u'search artist "anartist"') self.assert_(u'OK' in result) def test_search_filename(self): - result = self.h.handle_request(u'search "filename" "afilename"') + result = self.dispatcher.handle_request( + u'search "filename" "afilename"') self.assert_(u'OK' in result) def test_search_filename_without_quotes(self): - result = self.h.handle_request(u'search filename "afilename"') + result = self.dispatcher.handle_request(u'search filename "afilename"') self.assert_(u'OK' in result) def test_search_title(self): - result = self.h.handle_request(u'search "title" "atitle"') + result = self.dispatcher.handle_request(u'search "title" "atitle"') self.assert_(u'OK' in result) def test_search_title_without_quotes(self): - result = self.h.handle_request(u'search title "atitle"') + result = self.dispatcher.handle_request(u'search title "atitle"') self.assert_(u'OK' in result) def test_search_any(self): - result = self.h.handle_request(u'search "any" "anything"') + result = self.dispatcher.handle_request(u'search "any" "anything"') self.assert_(u'OK' in result) def test_search_any_without_quotes(self): - result = self.h.handle_request(u'search any "anything"') + result = self.dispatcher.handle_request(u'search any "anything"') self.assert_(u'OK' in result) def test_search_date(self): - result = self.h.handle_request(u'search "date" "2002-01-01"') + result = self.dispatcher.handle_request(u'search "date" "2002-01-01"') self.assert_(u'OK' in result) def test_search_date_without_quotes(self): - result = self.h.handle_request(u'search date "2002-01-01"') + result = self.dispatcher.handle_request(u'search date "2002-01-01"') self.assert_(u'OK' in result) def test_search_date_with_capital_d_and_incomplete_date(self): - result = self.h.handle_request(u'search Date "2005"') + result = self.dispatcher.handle_request(u'search Date "2005"') self.assert_(u'OK' in result) def test_search_else_should_fail(self): - result = self.h.handle_request(u'search "sometype" "something"') + result = self.dispatcher.handle_request( + u'search "sometype" "something"') self.assertEqual(result[0], u'ACK [2@0] {search} incorrect arguments') diff --git a/tests/frontends/mpd/playback_test.py b/tests/frontends/mpd/playback_test.py index 8601aa9c..e80943d6 100644 --- a/tests/frontends/mpd/playback_test.py +++ b/tests/frontends/mpd/playback_test.py @@ -2,7 +2,7 @@ import unittest from mopidy.backends.base import PlaybackController from mopidy.backends.dummy import DummyBackend -from mopidy.frontends.mpd import dispatcher +from mopidy.frontends.mpd.dispatcher import MpdDispatcher from mopidy.mixers.dummy import DummyMixer from mopidy.models import Track @@ -14,393 +14,378 @@ STOPPED = PlaybackController.STOPPED class PlaybackOptionsHandlerTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_consume_off(self): - result = self.h.handle_request(u'consume "0"') - self.assertFalse(self.b.playback.consume.get()) + result = self.dispatcher.handle_request(u'consume "0"') + self.assertFalse(self.backend.playback.consume.get()) self.assert_(u'OK' in result) def test_consume_off_without_quotes(self): - result = self.h.handle_request(u'consume 0') - self.assertFalse(self.b.playback.consume.get()) + result = self.dispatcher.handle_request(u'consume 0') + self.assertFalse(self.backend.playback.consume.get()) self.assert_(u'OK' in result) def test_consume_on(self): - result = self.h.handle_request(u'consume "1"') - self.assertTrue(self.b.playback.consume.get()) + result = self.dispatcher.handle_request(u'consume "1"') + self.assertTrue(self.backend.playback.consume.get()) self.assert_(u'OK' in result) def test_consume_on_without_quotes(self): - result = self.h.handle_request(u'consume 1') - self.assertTrue(self.b.playback.consume.get()) + result = self.dispatcher.handle_request(u'consume 1') + self.assertTrue(self.backend.playback.consume.get()) self.assert_(u'OK' in result) def test_crossfade(self): - result = self.h.handle_request(u'crossfade "10"') + result = self.dispatcher.handle_request(u'crossfade "10"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_random_off(self): - result = self.h.handle_request(u'random "0"') - self.assertFalse(self.b.playback.random.get()) + result = self.dispatcher.handle_request(u'random "0"') + self.assertFalse(self.backend.playback.random.get()) self.assert_(u'OK' in result) def test_random_off_without_quotes(self): - result = self.h.handle_request(u'random 0') - self.assertFalse(self.b.playback.random.get()) + result = self.dispatcher.handle_request(u'random 0') + self.assertFalse(self.backend.playback.random.get()) self.assert_(u'OK' in result) def test_random_on(self): - result = self.h.handle_request(u'random "1"') - self.assertTrue(self.b.playback.random.get()) + result = self.dispatcher.handle_request(u'random "1"') + self.assertTrue(self.backend.playback.random.get()) self.assert_(u'OK' in result) def test_random_on_without_quotes(self): - result = self.h.handle_request(u'random 1') - self.assertTrue(self.b.playback.random.get()) + result = self.dispatcher.handle_request(u'random 1') + self.assertTrue(self.backend.playback.random.get()) self.assert_(u'OK' in result) def test_repeat_off(self): - result = self.h.handle_request(u'repeat "0"') - self.assertFalse(self.b.playback.repeat.get()) + result = self.dispatcher.handle_request(u'repeat "0"') + self.assertFalse(self.backend.playback.repeat.get()) self.assert_(u'OK' in result) def test_repeat_off_without_quotes(self): - result = self.h.handle_request(u'repeat 0') - self.assertFalse(self.b.playback.repeat.get()) + result = self.dispatcher.handle_request(u'repeat 0') + self.assertFalse(self.backend.playback.repeat.get()) self.assert_(u'OK' in result) def test_repeat_on(self): - result = self.h.handle_request(u'repeat "1"') - self.assertTrue(self.b.playback.repeat.get()) + result = self.dispatcher.handle_request(u'repeat "1"') + self.assertTrue(self.backend.playback.repeat.get()) self.assert_(u'OK' in result) def test_repeat_on_without_quotes(self): - result = self.h.handle_request(u'repeat 1') - self.assertTrue(self.b.playback.repeat.get()) + result = self.dispatcher.handle_request(u'repeat 1') + self.assertTrue(self.backend.playback.repeat.get()) self.assert_(u'OK' in result) def test_setvol_below_min(self): - result = self.h.handle_request(u'setvol "-10"') + result = self.dispatcher.handle_request(u'setvol "-10"') self.assert_(u'OK' in result) self.assertEqual(0, self.mixer.volume.get()) def test_setvol_min(self): - result = self.h.handle_request(u'setvol "0"') + result = self.dispatcher.handle_request(u'setvol "0"') self.assert_(u'OK' in result) self.assertEqual(0, self.mixer.volume.get()) def test_setvol_middle(self): - result = self.h.handle_request(u'setvol "50"') + result = self.dispatcher.handle_request(u'setvol "50"') self.assert_(u'OK' in result) self.assertEqual(50, self.mixer.volume.get()) def test_setvol_max(self): - result = self.h.handle_request(u'setvol "100"') + result = self.dispatcher.handle_request(u'setvol "100"') self.assert_(u'OK' in result) self.assertEqual(100, self.mixer.volume.get()) def test_setvol_above_max(self): - result = self.h.handle_request(u'setvol "110"') + result = self.dispatcher.handle_request(u'setvol "110"') self.assert_(u'OK' in result) self.assertEqual(100, self.mixer.volume.get()) def test_setvol_plus_is_ignored(self): - result = self.h.handle_request(u'setvol "+10"') + result = self.dispatcher.handle_request(u'setvol "+10"') self.assert_(u'OK' in result) self.assertEqual(10, self.mixer.volume.get()) def test_setvol_without_quotes(self): - result = self.h.handle_request(u'setvol 50') + result = self.dispatcher.handle_request(u'setvol 50') self.assert_(u'OK' in result) self.assertEqual(50, self.mixer.volume.get()) def test_single_off(self): - result = self.h.handle_request(u'single "0"') - self.assertFalse(self.b.playback.single.get()) + result = self.dispatcher.handle_request(u'single "0"') + self.assertFalse(self.backend.playback.single.get()) self.assert_(u'OK' in result) def test_single_off_without_quotes(self): - result = self.h.handle_request(u'single 0') - self.assertFalse(self.b.playback.single.get()) + result = self.dispatcher.handle_request(u'single 0') + self.assertFalse(self.backend.playback.single.get()) self.assert_(u'OK' in result) def test_single_on(self): - result = self.h.handle_request(u'single "1"') - self.assertTrue(self.b.playback.single.get()) + result = self.dispatcher.handle_request(u'single "1"') + self.assertTrue(self.backend.playback.single.get()) self.assert_(u'OK' in result) def test_single_on_without_quotes(self): - result = self.h.handle_request(u'single 1') - self.assertTrue(self.b.playback.single.get()) + result = self.dispatcher.handle_request(u'single 1') + self.assertTrue(self.backend.playback.single.get()) self.assert_(u'OK' in result) def test_replay_gain_mode_off(self): - result = self.h.handle_request(u'replay_gain_mode "off"') + result = self.dispatcher.handle_request(u'replay_gain_mode "off"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_replay_gain_mode_track(self): - result = self.h.handle_request(u'replay_gain_mode "track"') + result = self.dispatcher.handle_request(u'replay_gain_mode "track"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_replay_gain_mode_album(self): - result = self.h.handle_request(u'replay_gain_mode "album"') + result = self.dispatcher.handle_request(u'replay_gain_mode "album"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_replay_gain_status_default(self): expected = u'off' - result = self.h.handle_request(u'replay_gain_status') + result = self.dispatcher.handle_request(u'replay_gain_status') self.assert_(u'OK' in result) self.assert_(expected in result) def test_replay_gain_status_off(self): - raise SkipTest - expected = u'off' - self.h._replay_gain_mode(expected) - result = self.h.handle_request(u'replay_gain_status') - self.assert_(u'OK' in result) - self.assert_(expected in result) + raise SkipTest # TODO def test_replay_gain_status_track(self): - raise SkipTest - expected = u'track' - self.h._replay_gain_mode(expected) - result = self.h.handle_request(u'replay_gain_status') - self.assert_(u'OK' in result) - self.assert_(expected in result) + raise SkipTest # TODO def test_replay_gain_status_album(self): - raise SkipTest - expected = u'album' - self.h._replay_gain_mode(expected) - result = self.h.handle_request(u'replay_gain_status') - self.assert_(u'OK' in result) - self.assert_(expected in result) + raise SkipTest # TODO class PlaybackControlHandlerTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_next(self): - result = self.h.handle_request(u'next') + result = self.dispatcher.handle_request(u'next') self.assert_(u'OK' in result) def test_pause_off(self): - self.b.current_playlist.append([Track()]) - self.h.handle_request(u'play "0"') - self.h.handle_request(u'pause "1"') - result = self.h.handle_request(u'pause "0"') + self.backend.current_playlist.append([Track()]) + self.dispatcher.handle_request(u'play "0"') + self.dispatcher.handle_request(u'pause "1"') + result = self.dispatcher.handle_request(u'pause "0"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) + self.assertEqual(PLAYING, self.backend.playback.state.get()) def test_pause_on(self): - self.b.current_playlist.append([Track()]) - self.h.handle_request(u'play "0"') - result = self.h.handle_request(u'pause "1"') + self.backend.current_playlist.append([Track()]) + self.dispatcher.handle_request(u'play "0"') + result = self.dispatcher.handle_request(u'pause "1"') self.assert_(u'OK' in result) - self.assertEqual(PAUSED, self.b.playback.state.get()) + self.assertEqual(PAUSED, self.backend.playback.state.get()) def test_pause_toggle(self): - self.b.current_playlist.append([Track()]) - result = self.h.handle_request(u'play "0"') + self.backend.current_playlist.append([Track()]) + result = self.dispatcher.handle_request(u'play "0"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) - result = self.h.handle_request(u'pause') + self.assertEqual(PLAYING, self.backend.playback.state.get()) + result = self.dispatcher.handle_request(u'pause') self.assert_(u'OK' in result) - self.assertEqual(PAUSED, self.b.playback.state.get()) - result = self.h.handle_request(u'pause') + self.assertEqual(PAUSED, self.backend.playback.state.get()) + result = self.dispatcher.handle_request(u'pause') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) + self.assertEqual(PLAYING, self.backend.playback.state.get()) def test_play_without_pos(self): - self.b.current_playlist.append([Track()]) - self.b.playback.state = PAUSED - result = self.h.handle_request(u'play') + self.backend.current_playlist.append([Track()]) + self.backend.playback.state = PAUSED + result = self.dispatcher.handle_request(u'play') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) + self.assertEqual(PLAYING, self.backend.playback.state.get()) def test_play_with_pos(self): - self.b.current_playlist.append([Track()]) - result = self.h.handle_request(u'play "0"') + self.backend.current_playlist.append([Track()]) + result = self.dispatcher.handle_request(u'play "0"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) + self.assertEqual(PLAYING, self.backend.playback.state.get()) def test_play_with_pos_without_quotes(self): - self.b.current_playlist.append([Track()]) - result = self.h.handle_request(u'play 0') + self.backend.current_playlist.append([Track()]) + result = self.dispatcher.handle_request(u'play 0') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) + self.assertEqual(PLAYING, self.backend.playback.state.get()) def test_play_with_pos_out_of_bounds(self): - self.b.current_playlist.append([]) - result = self.h.handle_request(u'play "0"') + self.backend.current_playlist.append([]) + result = self.dispatcher.handle_request(u'play "0"') self.assertEqual(result[0], u'ACK [2@0] {play} Bad song index') - self.assertEqual(STOPPED, self.b.playback.state.get()) + self.assertEqual(STOPPED, self.backend.playback.state.get()) def test_play_minus_one_plays_first_in_playlist_if_no_current_track(self): - self.assertEqual(self.b.playback.current_track.get(), None) - self.b.current_playlist.append([Track(uri='a'), Track(uri='b')]) - result = self.h.handle_request(u'play "-1"') + self.assertEqual(self.backend.playback.current_track.get(), None) + self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) + result = self.dispatcher.handle_request(u'play "-1"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) - self.assertEqual(self.b.playback.current_track.get().uri, 'a') + self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(self.backend.playback.current_track.get().uri, 'a') def test_play_minus_one_plays_current_track_if_current_track_is_set(self): - self.b.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.assertEqual(self.b.playback.current_track.get(), None) - self.b.playback.play() - self.b.playback.next() - self.b.playback.stop() - self.assertNotEqual(self.b.playback.current_track.get(), None) - result = self.h.handle_request(u'play "-1"') + self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEqual(self.backend.playback.current_track.get(), None) + self.backend.playback.play() + self.backend.playback.next() + self.backend.playback.stop() + self.assertNotEqual(self.backend.playback.current_track.get(), None) + result = self.dispatcher.handle_request(u'play "-1"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) - self.assertEqual(self.b.playback.current_track.get().uri, 'b') + self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(self.backend.playback.current_track.get().uri, 'b') def test_play_minus_one_on_empty_playlist_does_not_ack(self): - self.b.current_playlist.clear() - result = self.h.handle_request(u'play "-1"') + self.backend.current_playlist.clear() + result = self.dispatcher.handle_request(u'play "-1"') self.assert_(u'OK' in result) - self.assertEqual(STOPPED, self.b.playback.state.get()) - self.assertEqual(self.b.playback.current_track.get(), None) + self.assertEqual(STOPPED, self.backend.playback.state.get()) + self.assertEqual(self.backend.playback.current_track.get(), None) def test_play_minus_is_ignored_if_playing(self): - self.b.current_playlist.append([Track(length=40000)]) - self.b.playback.seek(30000) - self.assert_(self.b.playback.time_position.get() >= 30000) - self.assertEquals(PLAYING, self.b.playback.state.get()) - result = self.h.handle_request(u'play "-1"') + self.backend.current_playlist.append([Track(length=40000)]) + self.backend.playback.seek(30000) + self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertEquals(PLAYING, self.backend.playback.state.get()) + result = self.dispatcher.handle_request(u'play "-1"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) - self.assert_(self.b.playback.time_position.get() >= 30000) + self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assert_(self.backend.playback.time_position.get() >= 30000) def test_play_minus_one_resumes_if_paused(self): - self.b.current_playlist.append([Track(length=40000)]) - self.b.playback.seek(30000) - self.assert_(self.b.playback.time_position.get() >= 30000) - self.assertEquals(PLAYING, self.b.playback.state.get()) - self.b.playback.pause() - self.assertEquals(PAUSED, self.b.playback.state.get()) - result = self.h.handle_request(u'play "-1"') + self.backend.current_playlist.append([Track(length=40000)]) + self.backend.playback.seek(30000) + self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertEquals(PLAYING, self.backend.playback.state.get()) + self.backend.playback.pause() + self.assertEquals(PAUSED, self.backend.playback.state.get()) + result = self.dispatcher.handle_request(u'play "-1"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) - self.assert_(self.b.playback.time_position.get() >= 30000) + self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assert_(self.backend.playback.time_position.get() >= 30000) def test_playid(self): - self.b.current_playlist.append([Track()]) - result = self.h.handle_request(u'playid "0"') + self.backend.current_playlist.append([Track()]) + result = self.dispatcher.handle_request(u'playid "0"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) + self.assertEqual(PLAYING, self.backend.playback.state.get()) def test_playid_minus_one_plays_first_in_playlist_if_no_current_track(self): - self.assertEqual(self.b.playback.current_track.get(), None) - self.b.current_playlist.append([Track(uri='a'), Track(uri='b')]) - result = self.h.handle_request(u'playid "-1"') + self.assertEqual(self.backend.playback.current_track.get(), None) + self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) + result = self.dispatcher.handle_request(u'playid "-1"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) - self.assertEqual(self.b.playback.current_track.get().uri, 'a') + self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(self.backend.playback.current_track.get().uri, 'a') def test_playid_minus_one_plays_current_track_if_current_track_is_set(self): - self.b.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.assertEqual(self.b.playback.current_track.get(), None) - self.b.playback.play() - self.b.playback.next() - self.b.playback.stop() - self.assertNotEqual(self.b.playback.current_track.get(), None) - result = self.h.handle_request(u'playid "-1"') + self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEqual(self.backend.playback.current_track.get(), None) + self.backend.playback.play() + self.backend.playback.next() + self.backend.playback.stop() + self.assertNotEqual(self.backend.playback.current_track.get(), None) + result = self.dispatcher.handle_request(u'playid "-1"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) - self.assertEqual(self.b.playback.current_track.get().uri, 'b') + self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assertEqual(self.backend.playback.current_track.get().uri, 'b') def test_playid_minus_one_on_empty_playlist_does_not_ack(self): - self.b.current_playlist.clear() - result = self.h.handle_request(u'playid "-1"') + self.backend.current_playlist.clear() + result = self.dispatcher.handle_request(u'playid "-1"') self.assert_(u'OK' in result) - self.assertEqual(STOPPED, self.b.playback.state.get()) - self.assertEqual(self.b.playback.current_track.get(), None) + self.assertEqual(STOPPED, self.backend.playback.state.get()) + self.assertEqual(self.backend.playback.current_track.get(), None) def test_playid_minus_is_ignored_if_playing(self): - self.b.current_playlist.append([Track(length=40000)]) - self.b.playback.seek(30000) - self.assert_(self.b.playback.time_position.get() >= 30000) - self.assertEquals(PLAYING, self.b.playback.state.get()) - result = self.h.handle_request(u'playid "-1"') + self.backend.current_playlist.append([Track(length=40000)]) + self.backend.playback.seek(30000) + self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertEquals(PLAYING, self.backend.playback.state.get()) + result = self.dispatcher.handle_request(u'playid "-1"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) - self.assert_(self.b.playback.time_position.get() >= 30000) + self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assert_(self.backend.playback.time_position.get() >= 30000) def test_playid_minus_one_resumes_if_paused(self): - self.b.current_playlist.append([Track(length=40000)]) - self.b.playback.seek(30000) - self.assert_(self.b.playback.time_position.get() >= 30000) - self.assertEquals(PLAYING, self.b.playback.state.get()) - self.b.playback.pause() - self.assertEquals(PAUSED, self.b.playback.state.get()) - result = self.h.handle_request(u'playid "-1"') + self.backend.current_playlist.append([Track(length=40000)]) + self.backend.playback.seek(30000) + self.assert_(self.backend.playback.time_position.get() >= 30000) + self.assertEquals(PLAYING, self.backend.playback.state.get()) + self.backend.playback.pause() + self.assertEquals(PAUSED, self.backend.playback.state.get()) + result = self.dispatcher.handle_request(u'playid "-1"') self.assert_(u'OK' in result) - self.assertEqual(PLAYING, self.b.playback.state.get()) - self.assert_(self.b.playback.time_position.get() >= 30000) + self.assertEqual(PLAYING, self.backend.playback.state.get()) + self.assert_(self.backend.playback.time_position.get() >= 30000) def test_playid_which_does_not_exist(self): - self.b.current_playlist.append([Track()]) - result = self.h.handle_request(u'playid "12345"') + self.backend.current_playlist.append([Track()]) + result = self.dispatcher.handle_request(u'playid "12345"') self.assertEqual(result[0], u'ACK [50@0] {playid} No such song') def test_previous(self): - result = self.h.handle_request(u'previous') + result = self.dispatcher.handle_request(u'previous') self.assert_(u'OK' in result) def test_seek(self): - self.b.current_playlist.append([Track(length=40000)]) - self.h.handle_request(u'seek "0"') - result = self.h.handle_request(u'seek "0" "30"') + self.backend.current_playlist.append([Track(length=40000)]) + self.dispatcher.handle_request(u'seek "0"') + result = self.dispatcher.handle_request(u'seek "0" "30"') self.assert_(u'OK' in result) - self.assert_(self.b.playback.time_position >= 30000) + self.assert_(self.backend.playback.time_position >= 30000) def test_seek_with_songpos(self): seek_track = Track(uri='2', length=40000) - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(uri='1', length=40000), seek_track]) - result = self.h.handle_request(u'seek "1" "30"') + result = self.dispatcher.handle_request(u'seek "1" "30"') self.assert_(u'OK' in result) - self.assertEqual(self.b.playback.current_track.get(), seek_track) + self.assertEqual(self.backend.playback.current_track.get(), seek_track) def test_seek_without_quotes(self): - self.b.current_playlist.append([Track(length=40000)]) - self.h.handle_request(u'seek 0') - result = self.h.handle_request(u'seek 0 30') + self.backend.current_playlist.append([Track(length=40000)]) + self.dispatcher.handle_request(u'seek 0') + result = self.dispatcher.handle_request(u'seek 0 30') self.assert_(u'OK' in result) - self.assert_(self.b.playback.time_position.get() >= 30000) + self.assert_(self.backend.playback.time_position.get() >= 30000) def test_seekid(self): - self.b.current_playlist.append([Track(length=40000)]) - result = self.h.handle_request(u'seekid "0" "30"') + self.backend.current_playlist.append([Track(length=40000)]) + result = self.dispatcher.handle_request(u'seekid "0" "30"') self.assert_(u'OK' in result) - self.assert_(self.b.playback.time_position.get() >= 30000) + self.assert_(self.backend.playback.time_position.get() >= 30000) def test_seekid_with_cpid(self): seek_track = Track(uri='2', length=40000) - self.b.current_playlist.append( + self.backend.current_playlist.append( [Track(length=40000), seek_track]) - result = self.h.handle_request(u'seekid "1" "30"') + result = self.dispatcher.handle_request(u'seekid "1" "30"') self.assert_(u'OK' in result) - self.assertEqual(self.b.playback.current_cpid.get(), 1) - self.assertEqual(self.b.playback.current_track.get(), seek_track) + self.assertEqual(self.backend.playback.current_cpid.get(), 1) + self.assertEqual(self.backend.playback.current_track.get(), seek_track) def test_stop(self): - result = self.h.handle_request(u'stop') + result = self.dispatcher.handle_request(u'stop') self.assert_(u'OK' in result) - self.assertEqual(STOPPED, self.b.playback.state.get()) + self.assertEqual(STOPPED, self.backend.playback.state.get()) diff --git a/tests/frontends/mpd/reflection_test.py b/tests/frontends/mpd/reflection_test.py index be95c49b..c5cde1bb 100644 --- a/tests/frontends/mpd/reflection_test.py +++ b/tests/frontends/mpd/reflection_test.py @@ -1,21 +1,21 @@ import unittest from mopidy.backends.dummy import DummyBackend -from mopidy.frontends.mpd import dispatcher +from mopidy.frontends.mpd.dispatcher import MpdDispatcher from mopidy.mixers.dummy import DummyMixer class ReflectionHandlerTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_commands_returns_list_of_all_commands(self): - result = self.h.handle_request(u'commands') + result = self.dispatcher.handle_request(u'commands') # Check if some random commands are included self.assert_(u'command: commands' in result) self.assert_(u'command: play' in result) @@ -30,19 +30,19 @@ class ReflectionHandlerTest(unittest.TestCase): self.assert_(u'OK' in result) def test_decoders(self): - result = self.h.handle_request(u'decoders') + result = self.dispatcher.handle_request(u'decoders') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_notcommands_returns_only_ok(self): - result = self.h.handle_request(u'notcommands') + result = self.dispatcher.handle_request(u'notcommands') self.assertEqual(1, len(result)) self.assert_(u'OK' in result) def test_tagtypes(self): - result = self.h.handle_request(u'tagtypes') + result = self.dispatcher.handle_request(u'tagtypes') self.assert_(u'OK' in result) def test_urlhandlers(self): - result = self.h.handle_request(u'urlhandlers') + result = self.dispatcher.handle_request(u'urlhandlers') self.assert_(u'OK' in result) self.assert_(u'handler: dummy:' in result) diff --git a/tests/frontends/mpd/stickers_test.py b/tests/frontends/mpd/stickers_test.py index 83d43792..86ac8aec 100644 --- a/tests/frontends/mpd/stickers_test.py +++ b/tests/frontends/mpd/stickers_test.py @@ -1,45 +1,45 @@ import unittest from mopidy.backends.dummy import DummyBackend -from mopidy.frontends.mpd import dispatcher +from mopidy.frontends.mpd.dispatcher import MpdDispatcher from mopidy.mixers.dummy import DummyMixer class StickersHandlerTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_sticker_get(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'sticker get "song" "file:///dev/urandom" "a_name"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_sticker_set(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'sticker set "song" "file:///dev/urandom" "a_name" "a_value"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_sticker_delete_with_name(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'sticker delete "song" "file:///dev/urandom" "a_name"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_sticker_delete_without_name(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'sticker delete "song" "file:///dev/urandom"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_sticker_list(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'sticker list "song" "file:///dev/urandom"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_sticker_find(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'sticker find "song" "file:///dev/urandom" "a_name"') self.assert_(u'ACK [0@0] {} Not implemented' in result) diff --git a/tests/frontends/mpd/stored_playlists_test.py b/tests/frontends/mpd/stored_playlists_test.py index e981c9ed..04bab6f1 100644 --- a/tests/frontends/mpd/stored_playlists_test.py +++ b/tests/frontends/mpd/stored_playlists_test.py @@ -2,64 +2,64 @@ import datetime as dt import unittest from mopidy.backends.dummy import DummyBackend -from mopidy.frontends.mpd import dispatcher +from mopidy.frontends.mpd.dispatcher import MpdDispatcher from mopidy.mixers.dummy import DummyMixer from mopidy.models import Track, Playlist class StoredPlaylistsHandlerTest(unittest.TestCase): def setUp(self): - self.b = DummyBackend.start().proxy() + self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() - self.h = dispatcher.MpdDispatcher() + self.dispatcher = MpdDispatcher() def tearDown(self): - self.b.stop().get() + self.backend.stop().get() self.mixer.stop().get() def test_listplaylist(self): - self.b.stored_playlists.playlists = [ + self.backend.stored_playlists.playlists = [ Playlist(name='name', tracks=[Track(uri='file:///dev/urandom')])] - result = self.h.handle_request(u'listplaylist "name"') + result = self.dispatcher.handle_request(u'listplaylist "name"') self.assert_(u'file: file:///dev/urandom' in result) self.assert_(u'OK' in result) def test_listplaylist_fails_if_no_playlist_is_found(self): - result = self.h.handle_request(u'listplaylist "name"') + result = self.dispatcher.handle_request(u'listplaylist "name"') self.assertEqual(result[0], u'ACK [50@0] {listplaylist} No such playlist') def test_listplaylistinfo(self): - self.b.stored_playlists.playlists = [ + self.backend.stored_playlists.playlists = [ Playlist(name='name', tracks=[Track(uri='file:///dev/urandom')])] - result = self.h.handle_request(u'listplaylistinfo "name"') + result = self.dispatcher.handle_request(u'listplaylistinfo "name"') self.assert_(u'file: file:///dev/urandom' in result) self.assert_(u'Track: 0' in result) self.assert_(u'Pos: 0' not in result) self.assert_(u'OK' in result) def test_listplaylistinfo_fails_if_no_playlist_is_found(self): - result = self.h.handle_request(u'listplaylistinfo "name"') + result = self.dispatcher.handle_request(u'listplaylistinfo "name"') self.assertEqual(result[0], u'ACK [50@0] {listplaylistinfo} No such playlist') def test_listplaylists(self): last_modified = dt.datetime(2001, 3, 17, 13, 41, 17, 12345) - self.b.stored_playlists.playlists = [Playlist(name='a', + self.backend.stored_playlists.playlists = [Playlist(name='a', last_modified=last_modified)] - result = self.h.handle_request(u'listplaylists') + result = self.dispatcher.handle_request(u'listplaylists') self.assert_(u'playlist: a' in result) # Date without microseconds and with time zone information self.assert_(u'Last-Modified: 2001-03-17T13:41:17Z' in result) self.assert_(u'OK' in result) def test_load_known_playlist_appends_to_current_playlist(self): - self.b.current_playlist.append([Track(uri='a'), Track(uri='b')]) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 2) - self.b.stored_playlists.playlists = [Playlist(name='A-list', + self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')]) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 2) + self.backend.stored_playlists.playlists = [Playlist(name='A-list', tracks=[Track(uri='c'), Track(uri='d'), Track(uri='e')])] - result = self.h.handle_request(u'load "A-list"') + result = self.dispatcher.handle_request(u'load "A-list"') self.assert_(u'OK' in result) - tracks = self.b.current_playlist.tracks.get() + tracks = self.backend.current_playlist.tracks.get() self.assertEqual(len(tracks), 5) self.assertEqual(tracks[0].uri, 'a') self.assertEqual(tracks[1].uri, 'b') @@ -68,35 +68,35 @@ class StoredPlaylistsHandlerTest(unittest.TestCase): self.assertEqual(tracks[4].uri, 'e') def test_load_unknown_playlist_acks(self): - result = self.h.handle_request(u'load "unknown playlist"') + result = self.dispatcher.handle_request(u'load "unknown playlist"') self.assert_(u'ACK [50@0] {load} No such playlist' in result) - self.assertEqual(len(self.b.current_playlist.tracks.get()), 0) + self.assertEqual(len(self.backend.current_playlist.tracks.get()), 0) def test_playlistadd(self): - result = self.h.handle_request( + result = self.dispatcher.handle_request( u'playlistadd "name" "file:///dev/urandom"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_playlistclear(self): - result = self.h.handle_request(u'playlistclear "name"') + result = self.dispatcher.handle_request(u'playlistclear "name"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_playlistdelete(self): - result = self.h.handle_request(u'playlistdelete "name" "5"') + result = self.dispatcher.handle_request(u'playlistdelete "name" "5"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_playlistmove(self): - result = self.h.handle_request(u'playlistmove "name" "5" "10"') + result = self.dispatcher.handle_request(u'playlistmove "name" "5" "10"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_rename(self): - result = self.h.handle_request(u'rename "old_name" "new_name"') + result = self.dispatcher.handle_request(u'rename "old_name" "new_name"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_rm(self): - result = self.h.handle_request(u'rm "name"') + result = self.dispatcher.handle_request(u'rm "name"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_save(self): - result = self.h.handle_request(u'save "name"') + result = self.dispatcher.handle_request(u'save "name"') self.assert_(u'ACK [0@0] {} Not implemented' in result)