def setUp(self): config = { 'mpd': { 'password': None, } } self.backend = dummy.create_dummy_backend_proxy() self.core = core.Core.start(backends=[self.backend]).proxy() self.dispatcher = MpdDispatcher(config=config)
class MpdDispatcherTest(unittest.TestCase): def setUp(self): config = { 'mpd': { 'password': None, } } self.backend = dummy.create_dummy_backend_proxy() self.core = core.Core.start(backends=[self.backend]).proxy() self.dispatcher = MpdDispatcher(config=config) def tearDown(self): pykka.ActorRegistry.stop_all() def test_register_same_pattern_twice_fails(self): func = lambda: None try: handle_request('a pattern')(func) handle_request('a pattern')(func) self.fail('Registering a pattern twice shoulde raise ValueError') except ValueError: pass def test_finding_handler_for_unknown_command_raises_exception(self): try: self.dispatcher._find_handler('an_unknown_command with args') self.fail('Should raise exception') except MpdAckError as e: self.assertEqual( e.get_mpd_ack(), 'ACK [5@0] {} unknown command "an_unknown_command"') def test_find_handler_for_known_command_returns_handler_and_kwargs(self): expected_handler = lambda x: None request_handlers['known_command (?P<arg1>.+)'] = \ expected_handler (handler, kwargs) = self.dispatcher._find_handler( 'known_command an_arg') self.assertEqual(handler, expected_handler) self.assertIn('arg1', kwargs) self.assertEqual(kwargs['arg1'], 'an_arg') def test_handling_unknown_request_yields_error(self): result = self.dispatcher.handle_request('an unhandled request') self.assertEqual(result[0], 'ACK [5@0] {} unknown command "an"') def test_handling_known_request(self): expected = 'magic' request_handlers['known request'] = lambda x: expected result = self.dispatcher.handle_request('known request') self.assertIn('OK', result) self.assertIn(expected, result)
class MpdDispatcherTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_register_same_pattern_twice_fails(self): func = lambda: None try: handle_request('a pattern')(func) handle_request('a pattern')(func) self.fail('Registering a pattern twice shoulde raise ValueError') except ValueError: pass def test_finding_handler_for_unknown_command_raises_exception(self): try: self.dispatcher._find_handler('an_unknown_command with args') self.fail('Should raise exception') except MpdAckError as e: self.assertEqual( e.get_mpd_ack(), u'ACK [5@0] {} unknown command "an_unknown_command"') def test_finding_handler_for_known_command_returns_handler_and_kwargs( self): expected_handler = lambda x: None request_handlers['known_command (?P<arg1>.+)'] = \ expected_handler (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.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.dispatcher.handle_request('known request') self.assert_(u'OK' in result) self.assert_(expected in result)
class AuthenticationTest(unittest.TestCase): def setUp(self): self.session = mock.Mock(spec=MpdSession) self.dispatcher = MpdDispatcher(session=self.session) def tearDown(self): settings.runtime.clear() def test_authentication_with_valid_password_is_accepted(self): settings.MPD_SERVER_PASSWORD = u'topsecret' response = self.dispatcher.handle_request(u'password "topsecret"') self.assertTrue(self.dispatcher.authenticated) self.assert_(u'OK' in response) def test_authentication_with_invalid_password_is_not_accepted(self): settings.MPD_SERVER_PASSWORD = u'topsecret' response = self.dispatcher.handle_request(u'password "secret"') self.assertFalse(self.dispatcher.authenticated) self.assert_(u'ACK [3@0] {password} incorrect password' in response) def test_authentication_with_anything_when_password_check_turned_off(self): settings.MPD_SERVER_PASSWORD = None response = self.dispatcher.handle_request(u'any request at all') self.assertTrue(self.dispatcher.authenticated) self.assert_('ACK [5@0] {} unknown command "any"' in response) def test_anything_when_not_authenticated_should_fail(self): settings.MPD_SERVER_PASSWORD = u'topsecret' response = self.dispatcher.handle_request(u'any request at all') self.assertFalse(self.dispatcher.authenticated) self.assert_( u'ACK [4@0] {any} you don\'t have permission for "any"' in response) def test_close_is_allowed_without_authentication(self): settings.MPD_SERVER_PASSWORD = u'topsecret' response = self.dispatcher.handle_request(u'close') self.assertFalse(self.dispatcher.authenticated) self.assert_(u'OK' in response) def test_commands_is_allowed_without_authentication(self): settings.MPD_SERVER_PASSWORD = u'topsecret' response = self.dispatcher.handle_request(u'commands') self.assertFalse(self.dispatcher.authenticated) self.assert_(u'OK' in response) def test_notcommands_is_allowed_without_authentication(self): settings.MPD_SERVER_PASSWORD = u'topsecret' response = self.dispatcher.handle_request(u'notcommands') self.assertFalse(self.dispatcher.authenticated) self.assert_(u'OK' in response) def test_ping_is_allowed_without_authentication(self): settings.MPD_SERVER_PASSWORD = u'topsecret' response = self.dispatcher.handle_request(u'ping') self.assertFalse(self.dispatcher.authenticated) self.assert_(u'OK' in response)
class MpdDispatcherTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_register_same_pattern_twice_fails(self): func = lambda: None try: handle_request('a pattern')(func) handle_request('a pattern')(func) self.fail('Registering a pattern twice shoulde raise ValueError') except ValueError: pass def test_finding_handler_for_unknown_command_raises_exception(self): try: self.dispatcher._find_handler('an_unknown_command with args') self.fail('Should raise exception') except MpdAckError as e: self.assertEqual(e.get_mpd_ack(), u'ACK [5@0] {} unknown command "an_unknown_command"') def test_finding_handler_for_known_command_returns_handler_and_kwargs(self): expected_handler = lambda x: None request_handlers['known_command (?P<arg1>.+)'] = \ expected_handler (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.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.dispatcher.handle_request('known request') self.assert_(u'OK' in result) self.assert_(expected in result)
def __init__(self, server, client_socket, client_socket_address): asynchat.async_chat.__init__(self, sock=client_socket) self.server = server self.client_address = client_socket_address[0] self.client_port = client_socket_address[1] self.input_buffer = [] self.authenticated = False self.set_terminator(LINE_TERMINATOR.encode(ENCODING)) self.dispatcher = MpdDispatcher(session=self) self.send_response([u'OK MPD %s' % VERSION])
class MpdSession(asynchat.async_chat): """ The MPD client session. Keeps track of a single client session. Any requests from the client is passed on to the MPD request dispatcher. """ def __init__(self, server, client_socket, client_socket_address): asynchat.async_chat.__init__(self, sock=client_socket) self.server = server self.client_address = client_socket_address[0] self.client_port = client_socket_address[1] self.input_buffer = [] self.authenticated = False self.set_terminator(LINE_TERMINATOR.encode(ENCODING)) self.dispatcher = MpdDispatcher(session=self) self.send_response([u'OK MPD %s' % VERSION]) def collect_incoming_data(self, data): """Called by asynchat when new data arrives.""" self.input_buffer.append(data) def found_terminator(self): """Called by asynchat when a terminator is found in incoming data.""" data = ''.join(self.input_buffer).strip() self.input_buffer = [] try: self.send_response(self.handle_request(data)) except UnicodeDecodeError as e: logger.warning(u'Received invalid data: %s', e) def handle_request(self, request): """Handle the request using the MPD command handlers.""" request = request.decode(ENCODING) logger.debug(u'Request from [%s]:%s: %s', self.client_address, self.client_port, indent(request)) return self.dispatcher.handle_request(request) def send_response(self, response): """ Format a response from the MPD command handlers and send it to the client. """ if response: response = LINE_TERMINATOR.join(response) logger.debug(u'Response to [%s]:%s: %s', self.client_address, self.client_port, indent(response)) response = u'%s%s' % (response, LINE_TERMINATOR) data = response.encode(ENCODING) self.push(data)
class AudioOutputHandlerTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_enableoutput(self): result = self.dispatcher.handle_request(u'enableoutput "0"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_disableoutput(self): result = self.dispatcher.handle_request(u'disableoutput "0"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_outputs(self): 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) self.assert_(u'OK' in result)
class MpdFrontend(BaseFrontend): """ The MPD frontend. **Settings:** - :attr:`mopidy.settings.MPD_SERVER_HOSTNAME` - :attr:`mopidy.settings.MPD_SERVER_PASSWORD` - :attr:`mopidy.settings.MPD_SERVER_PORT` """ def __init__(self, *args, **kwargs): super(MpdFrontend, self).__init__(*args, **kwargs) self.thread = None self.dispatcher = MpdDispatcher(self.backend) def start(self): """Starts the MPD server.""" self.thread = MpdThread(self.core_queue) self.thread.start() def destroy(self): """Destroys the MPD server.""" self.thread.destroy() def process_message(self, message): """ Processes messages with the MPD frontend as destination. :param message: the message :type message: dict """ assert message['to'] == 'frontend', \ u'Message recipient must be "frontend".' if message['command'] == 'mpd_request': response = self.dispatcher.handle_request(message['request']) connection = unpickle_connection(message['reply_to']) connection.send(response) else: pass # Ignore messages for other frontends
class StickersHandlerTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_sticker_get(self): 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.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.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.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.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.dispatcher.handle_request( u'sticker find "song" "file:///dev/urandom" "a_name"') self.assert_(u'ACK [0@0] {} Not implemented' in result)
class MusicDatabaseSearchTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_search_album(self): result = self.dispatcher.handle_request(u'search "album" "analbum"') self.assert_(u'OK' in result) def test_search_album_without_quotes(self): result = self.dispatcher.handle_request(u'search album "analbum"') self.assert_(u'OK' in result) def test_search_artist(self): result = self.dispatcher.handle_request(u'search "artist" "anartist"') self.assert_(u'OK' in result) def test_search_artist_without_quotes(self): result = self.dispatcher.handle_request(u'search artist "anartist"') self.assert_(u'OK' in result) def test_search_filename(self): result = self.dispatcher.handle_request( u'search "filename" "afilename"') self.assert_(u'OK' in result) def test_search_filename_without_quotes(self): result = self.dispatcher.handle_request(u'search filename "afilename"') self.assert_(u'OK' in result) def test_search_title(self): result = self.dispatcher.handle_request(u'search "title" "atitle"') self.assert_(u'OK' in result) def test_search_title_without_quotes(self): result = self.dispatcher.handle_request(u'search title "atitle"') self.assert_(u'OK' in result) def test_search_any(self): result = self.dispatcher.handle_request(u'search "any" "anything"') self.assert_(u'OK' in result) def test_search_any_without_quotes(self): result = self.dispatcher.handle_request(u'search any "anything"') self.assert_(u'OK' in result) def test_search_date(self): 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.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.dispatcher.handle_request(u'search Date "2005"') self.assert_(u'OK' in result) def test_search_else_should_fail(self): result = self.dispatcher.handle_request( u'search "sometype" "something"') self.assertEqual(result[0], u'ACK [2@0] {search} incorrect arguments')
def __init__(self, *args, **kwargs): super(MpdFrontend, self).__init__(*args, **kwargs) self.thread = None self.dispatcher = MpdDispatcher(self.backend)
class StoredPlaylistsHandlerTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_listplaylist(self): self.backend.stored_playlists.playlists = [ Playlist(name='name', tracks=[Track(uri='file:///dev/urandom')])] 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.dispatcher.handle_request(u'listplaylist "name"') self.assertEqual(result[0], u'ACK [50@0] {listplaylist} No such playlist') def test_listplaylistinfo(self): self.backend.stored_playlists.playlists = [ Playlist(name='name', tracks=[Track(uri='file:///dev/urandom')])] 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.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.backend.stored_playlists.playlists = [Playlist(name='a', last_modified=last_modified)] 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.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.dispatcher.handle_request(u'load "A-list"') self.assert_(u'OK' in result) tracks = self.backend.current_playlist.tracks.get() self.assertEqual(len(tracks), 5) self.assertEqual(tracks[0].uri, 'a') self.assertEqual(tracks[1].uri, 'b') self.assertEqual(tracks[2].uri, 'c') self.assertEqual(tracks[3].uri, 'd') self.assertEqual(tracks[4].uri, 'e') def test_load_unknown_playlist_acks(self): 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.backend.current_playlist.tracks.get()), 0) def test_playlistadd(self): 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.dispatcher.handle_request(u'playlistclear "name"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_playlistdelete(self): 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.dispatcher.handle_request(u'playlistmove "name" "5" "10"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_rename(self): 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.dispatcher.handle_request(u'rm "name"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_save(self): result = self.dispatcher.handle_request(u'save "name"') self.assert_(u'ACK [0@0] {} Not implemented' in result)
class StatusHandlerTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() self.context = self.dispatcher.context def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_clearerror(self): result = self.dispatcher.handle_request(u"clearerror") self.assert_(u"ACK [0@0] {} Not implemented" in result) def test_currentsong(self): track = Track() self.backend.current_playlist.append([track]) self.backend.playback.play() result = self.dispatcher.handle_request(u"currentsong") self.assert_(u"file: " in result) self.assert_(u"Time: 0" in result) self.assert_(u"Artist: " in result) self.assert_(u"Title: " in result) self.assert_(u"Album: " in result) self.assert_(u"Track: 0" in result) self.assert_(u"Date: " in result) self.assert_(u"Pos: 0" in result) self.assert_(u"Id: 0" in result) self.assert_(u"OK" in result) def test_currentsong_without_song(self): result = self.dispatcher.handle_request(u"currentsong") self.assert_(u"OK" in result) def test_idle_without_subsystems(self): result = self.dispatcher.handle_request(u"idle") self.assert_(u"OK" in result) def test_idle_with_subsystems(self): result = self.dispatcher.handle_request(u"idle database playlist") self.assert_(u"OK" in result) def test_noidle(self): result = self.dispatcher.handle_request(u"noidle") self.assert_(u"OK" in result) def test_stats_command(self): result = self.dispatcher.handle_request(u"stats") self.assert_(u"OK" in result) def test_stats_method(self): result = status.stats(self.context) self.assert_("artists" in result) self.assert_(int(result["artists"]) >= 0) self.assert_("albums" in result) self.assert_(int(result["albums"]) >= 0) self.assert_("songs" in result) self.assert_(int(result["songs"]) >= 0) self.assert_("uptime" in result) self.assert_(int(result["uptime"]) >= 0) self.assert_("db_playtime" in result) self.assert_(int(result["db_playtime"]) >= 0) self.assert_("db_update" in result) self.assert_(int(result["db_update"]) >= 0) self.assert_("playtime" in result) self.assert_(int(result["playtime"]) >= 0) def test_status_command(self): result = self.dispatcher.handle_request(u"status") self.assert_(u"OK" in result) def test_status_method_contains_volume_which_defaults_to_0(self): result = dict(status.status(self.context)) self.assert_("volume" in result) self.assertEqual(int(result["volume"]), 0) def test_status_method_contains_volume(self): self.mixer.volume = 17 result = dict(status.status(self.context)) self.assert_("volume" in result) self.assertEqual(int(result["volume"]), 17) def test_status_method_contains_repeat_is_0(self): result = dict(status.status(self.context)) self.assert_("repeat" in result) self.assertEqual(int(result["repeat"]), 0) def test_status_method_contains_repeat_is_1(self): self.backend.playback.repeat = 1 result = dict(status.status(self.context)) self.assert_("repeat" in result) self.assertEqual(int(result["repeat"]), 1) def test_status_method_contains_random_is_0(self): result = dict(status.status(self.context)) self.assert_("random" in result) self.assertEqual(int(result["random"]), 0) def test_status_method_contains_random_is_1(self): self.backend.playback.random = 1 result = dict(status.status(self.context)) self.assert_("random" in result) self.assertEqual(int(result["random"]), 1) def test_status_method_contains_single(self): result = dict(status.status(self.context)) self.assert_("single" in result) self.assert_(int(result["single"]) in (0, 1)) def test_status_method_contains_consume_is_0(self): result = dict(status.status(self.context)) self.assert_("consume" in result) self.assertEqual(int(result["consume"]), 0) def test_status_method_contains_consume_is_1(self): self.backend.playback.consume = 1 result = dict(status.status(self.context)) self.assert_("consume" in result) self.assertEqual(int(result["consume"]), 1) def test_status_method_contains_playlist(self): result = dict(status.status(self.context)) self.assert_("playlist" in result) self.assert_(int(result["playlist"]) in xrange(0, 2 ** 31 - 1)) def test_status_method_contains_playlistlength(self): result = dict(status.status(self.context)) self.assert_("playlistlength" in result) self.assert_(int(result["playlistlength"]) >= 0) def test_status_method_contains_xfade(self): result = dict(status.status(self.context)) self.assert_("xfade" in result) self.assert_(int(result["xfade"]) >= 0) def test_status_method_contains_state_is_play(self): self.backend.playback.state = PLAYING result = dict(status.status(self.context)) self.assert_("state" in result) self.assertEqual(result["state"], "play") def test_status_method_contains_state_is_stop(self): self.backend.playback.state = STOPPED result = dict(status.status(self.context)) self.assert_("state" in result) self.assertEqual(result["state"], "stop") def test_status_method_contains_state_is_pause(self): self.backend.playback.state = PLAYING self.backend.playback.state = PAUSED result = dict(status.status(self.context)) self.assert_("state" in result) self.assertEqual(result["state"], "pause") def test_status_method_when_playlist_loaded_contains_song(self): self.backend.current_playlist.append([Track()]) self.backend.playback.play() result = dict(status.status(self.context)) self.assert_("song" in result) self.assert_(int(result["song"]) >= 0) def test_status_method_when_playlist_loaded_contains_cpid_as_songid(self): self.backend.current_playlist.append([Track()]) self.backend.playback.play() result = dict(status.status(self.context)) self.assert_("songid" in result) self.assertEqual(int(result["songid"]), 0) def test_status_method_when_playing_contains_time_with_no_length(self): self.backend.current_playlist.append([Track(length=None)]) self.backend.playback.play() result = dict(status.status(self.context)) self.assert_("time" in result) (position, total) = result["time"].split(":") position = int(position) total = int(total) self.assert_(position <= total) def test_status_method_when_playing_contains_time_with_length(self): self.backend.current_playlist.append([Track(length=10000)]) self.backend.playback.play() result = dict(status.status(self.context)) self.assert_("time" in result) (position, total) = result["time"].split(":") position = int(position) total = int(total) self.assert_(position <= total) def test_status_method_when_playing_contains_elapsed(self): self.backend.playback.state = PAUSED self.backend.playback.play_time_accumulated = 59123 result = dict(status.status(self.context)) self.assert_("elapsed" in result) self.assertEqual(int(result["elapsed"]), 59123) def test_status_method_when_playing_contains_bitrate(self): self.backend.current_playlist.append([Track(bitrate=320)]) self.backend.playback.play() result = dict(status.status(self.context)) self.assert_("bitrate" in result) self.assertEqual(int(result["bitrate"]), 320)
class CurrentPlaylistHandlerTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_add(self): needle = Track(uri='dummy://foo') self.backend.library.provider.dummy_library = [ Track(), Track(), needle, Track()] self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) 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.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.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.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.backend.library.provider.dummy_library = [ Track(), Track(), needle, Track()] self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) 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.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.backend.library.provider.dummy_library = [ Track(), Track(), needle, Track()] self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) 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.backend.library.provider.dummy_library = [ Track(), Track(), needle, Track()] self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) 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.dispatcher.handle_request(u'addid "dummy://foo"') self.assertEqual(result[0], u'ACK [50@0] {addid} No such song') def test_clear(self): self.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) 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.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) 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.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) 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.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) 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.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) 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.backend.current_playlist.append( [Track(), Track(), Track(), Track(), Track()]) 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.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.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.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) 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') self.assertEqual(tracks[3].name, 'd') self.assertEqual(tracks[4].name, 'e') self.assertEqual(tracks[5].name, 'f') self.assert_(u'OK' in result) def test_move_open_range(self): 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.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') self.assertEqual(tracks[3].name, 'f') self.assertEqual(tracks[4].name, 'a') self.assertEqual(tracks[5].name, 'b') self.assert_(u'OK' in result) def test_move_closed_range(self): 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.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') self.assertEqual(tracks[3].name, 'd') self.assertEqual(tracks[4].name, 'e') self.assertEqual(tracks[5].name, 'f') self.assert_(u'OK' in result) def test_moveid(self): 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.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') self.assertEqual(tracks[3].name, 'c') self.assertEqual(tracks[4].name, 'd') self.assertEqual(tracks[5].name, 'f') self.assert_(u'OK' in result) def test_playlist_returns_same_as_playlistinfo(self): 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.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.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.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.backend.current_playlist.append([ Track(uri='file:///exists')]) 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) self.assert_(u'Pos: 0' in result) self.assert_(u'OK' in result) def test_playlistid_without_songid(self): 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.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) self.assert_(u'Id: 1' in result) self.assert_(u'OK' in result) def test_playlistid_with_not_existing_songid_fails(self): 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.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) 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) self.assert_(u'Title: d' in result) self.assert_(u'Title: e' in result) self.assert_(u'Title: f' in result) self.assert_(u'OK' in result) def test_playlistinfo_with_songpos(self): 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.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) self.assert_(u'Title: d' not in result) self.assert_(u'Title: e' in result) self.assert_(u'Title: f' not in result) self.assert_(u'OK' in result) def test_playlistinfo_with_negative_songpos_same_as_playlistinfo(self): 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.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) 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) self.assert_(u'Title: d' in result) self.assert_(u'Title: e' in result) self.assert_(u'Title: f' in result) self.assert_(u'OK' in result) def test_playlistinfo_with_closed_range(self): 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.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) self.assert_(u'Title: d' in result) self.assert_(u'Title: e' not in result) self.assert_(u'Title: f' not in result) self.assert_(u'OK' in result) def test_playlistinfo_with_too_high_start_of_range_returns_arg_error(self): 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.dispatcher.handle_request(u'playlistinfo "0:20"') self.assert_(u'OK' in result) def test_playlistsearch(self): 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.dispatcher.handle_request(u'playlistsearch any "needle"') self.assert_(u'ACK [0@0] {} Not implemented' in result) def test_plchanges(self): self.backend.current_playlist.append( [Track(name='a'), Track(name='b'), Track(name='c')]) 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.backend.current_playlist.append( [Track(name='a'), Track(name='b'), Track(name='c')]) 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.backend.current_playlist.append( [Track(name='a'), Track(name='b'), Track(name='c')]) 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.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) self.assert_(u'cpos: 2' in result) self.assert_(u'Id: %d' % cp_tracks[1][0] in result) self.assert_(u'cpos: 2' in result) self.assert_(u'Id: %d' % cp_tracks[2][0] in result) self.assert_(u'OK' in result) def test_shuffle_without_range(self): 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.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.backend.current_playlist.append([ Track(name='a'), Track(name='b'), Track(name='c'), Track(name='d'), Track(name='e'), Track(name='f'), ]) 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') self.assertEqual(tracks[3].name, 'd') self.assert_(u'OK' in result) def test_shuffle_with_closed_range(self): 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.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') self.assertEqual(tracks[5].name, 'f') self.assert_(u'OK' in result) def test_swap(self): 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.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') self.assertEqual(tracks[3].name, 'd') self.assertEqual(tracks[4].name, 'b') self.assertEqual(tracks[5].name, 'f') self.assert_(u'OK' in result) def test_swapid(self): 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.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') self.assertEqual(tracks[3].name, 'd') self.assertEqual(tracks[4].name, 'b') self.assertEqual(tracks[5].name, 'f') self.assert_(u'OK' in result)
def setUp(self): self.session = mock.Mock(spec=MpdSession) self.dispatcher = MpdDispatcher(session=self.session)
def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher()
def setUp(self): self.backend = dummy.DummyBackend.start(audio=None).proxy() self.core = core.Core.start(backends=[self.backend]).proxy() self.dispatcher = MpdDispatcher()
class PlaybackControlHandlerTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_next(self): result = self.dispatcher.handle_request(u"next") self.assert_(u"OK" in result) def test_pause_off(self): 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.backend.playback.state.get()) def test_pause_on(self): 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.backend.playback.state.get()) def test_pause_toggle(self): self.backend.current_playlist.append([Track()]) result = self.dispatcher.handle_request(u'play "0"') self.assert_(u"OK" in result) 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.backend.playback.state.get()) result = self.dispatcher.handle_request(u"pause") self.assert_(u"OK" in result) self.assertEqual(PLAYING, self.backend.playback.state.get()) def test_play_without_pos(self): 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.backend.playback.state.get()) def test_play_with_pos(self): self.backend.current_playlist.append([Track()]) result = self.dispatcher.handle_request(u'play "0"') self.assert_(u"OK" in result) self.assertEqual(PLAYING, self.backend.playback.state.get()) def test_play_with_pos_without_quotes(self): self.backend.current_playlist.append([Track()]) result = self.dispatcher.handle_request(u"play 0") self.assert_(u"OK" in result) self.assertEqual(PLAYING, self.backend.playback.state.get()) def test_play_with_pos_out_of_bounds(self): 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.backend.playback.state.get()) def test_play_minus_one_plays_first_in_playlist_if_no_current_track(self): 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.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.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.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.backend.current_playlist.clear() result = self.dispatcher.handle_request(u'play "-1"') self.assert_(u"OK" in result) 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.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.backend.playback.state.get()) self.assert_(self.backend.playback.time_position.get() >= 30000) def test_play_minus_one_resumes_if_paused(self): 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.backend.playback.state.get()) self.assert_(self.backend.playback.time_position.get() >= 30000) def test_playid(self): self.backend.current_playlist.append([Track()]) result = self.dispatcher.handle_request(u'playid "0"') self.assert_(u"OK" in result) 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.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.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.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.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.backend.current_playlist.clear() result = self.dispatcher.handle_request(u'playid "-1"') self.assert_(u"OK" in result) 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.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.backend.playback.state.get()) self.assert_(self.backend.playback.time_position.get() >= 30000) def test_playid_minus_one_resumes_if_paused(self): 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.backend.playback.state.get()) self.assert_(self.backend.playback.time_position.get() >= 30000) def test_playid_which_does_not_exist(self): 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.dispatcher.handle_request(u"previous") self.assert_(u"OK" in result) def test_seek(self): 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.backend.playback.time_position >= 30000) def test_seek_with_songpos(self): seek_track = Track(uri="2", length=40000) self.backend.current_playlist.append([Track(uri="1", length=40000), seek_track]) result = self.dispatcher.handle_request(u'seek "1" "30"') self.assert_(u"OK" in result) self.assertEqual(self.backend.playback.current_track.get(), seek_track) def test_seek_without_quotes(self): 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.backend.playback.time_position.get() >= 30000) def test_seekid(self): 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.backend.playback.time_position.get() >= 30000) def test_seekid_with_cpid(self): seek_track = Track(uri="2", length=40000) self.backend.current_playlist.append([Track(length=40000), seek_track]) result = self.dispatcher.handle_request(u'seekid "1" "30"') self.assert_(u"OK" in result) 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.dispatcher.handle_request(u"stop") self.assert_(u"OK" in result) self.assertEqual(STOPPED, self.backend.playback.state.get())
class MusicDatabaseListTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_list_foo_returns_ack(self): 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.dispatcher.handle_request(u'list "artist"') self.assert_(u'OK' in result) def test_list_artist_without_quotes(self): 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.dispatcher.handle_request(u'list Artist') self.assert_(u'OK' in result) def test_list_artist_with_query_of_one_token(self): 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.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.dispatcher.handle_request( u'list "artist" "artist" "anartist"') self.assert_(u'OK' in result) def test_list_artist_by_album(self): 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.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.dispatcher.handle_request( u'list "artist" "date" "2001"') self.assert_(u'OK' in result) def test_list_artist_by_genre(self): 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.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.dispatcher.handle_request(u'list "album"') self.assert_(u'OK' in result) def test_list_album_without_quotes(self): 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.dispatcher.handle_request(u'list Album') self.assert_(u'OK' in result) def test_list_album_with_artist_name(self): result = self.dispatcher.handle_request(u'list "album" "anartist"') self.assert_(u'OK' in result) def test_list_album_by_artist(self): 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.dispatcher.handle_request( u'list "album" "album" "analbum"') self.assert_(u'OK' in result) def test_list_album_by_full_date(self): 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.dispatcher.handle_request( u'list "album" "date" "2001"') self.assert_(u'OK' in result) def test_list_album_by_genre(self): 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.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.dispatcher.handle_request(u'list "date"') self.assert_(u'OK' in result) def test_list_date_without_quotes(self): 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.dispatcher.handle_request(u'list Date') self.assert_(u'OK' in result) def test_list_date_with_query_of_one_token(self): 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.dispatcher.handle_request( u'list "date" "artist" "anartist"') self.assert_(u'OK' in result) def test_list_date_by_album(self): 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.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.dispatcher.handle_request(u'list "date" "date" "2001"') self.assert_(u'OK' in result) def test_list_date_by_genre(self): 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.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.dispatcher.handle_request(u'list "genre"') self.assert_(u'OK' in result) def test_list_genre_without_quotes(self): 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.dispatcher.handle_request(u'list Genre') self.assert_(u'OK' in result) def test_list_genre_with_query_of_one_token(self): 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.dispatcher.handle_request( u'list "genre" "artist" "anartist"') self.assert_(u'OK' in result) def test_list_genre_by_album(self): 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.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.dispatcher.handle_request( u'list "genre" "date" "2001"') self.assert_(u'OK' in result) def test_list_genre_by_genre(self): 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.dispatcher.handle_request( u'list "genre" "artist" "anartist" "album" "analbum"') self.assert_(u'OK' in result)
class PlaybackOptionsHandlerTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_consume_off(self): 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.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.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.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.dispatcher.handle_request(u'crossfade "10"') self.assert_(u"ACK [0@0] {} Not implemented" in result) def test_random_off(self): 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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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 # TODO def test_replay_gain_status_track(self): raise SkipTest # TODO def test_replay_gain_status_album(self): raise SkipTest # TODO
class MusicDatabaseHandlerTest(unittest.TestCase): def setUp(self): self.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_count(self): 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.dispatcher.handle_request(u'findadd "album" "what"') self.assert_(u'OK' in result) def test_listall(self): 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.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.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.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.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.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.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.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.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.backend = DummyBackend.start().proxy() self.mixer = DummyMixer.start().proxy() self.dispatcher = MpdDispatcher() def tearDown(self): self.backend.stop().get() self.mixer.stop().get() def test_find_album(self): result = self.dispatcher.handle_request(u'find "album" "what"') self.assert_(u'OK' in result) def test_find_album_without_quotes(self): result = self.dispatcher.handle_request(u'find album "what"') self.assert_(u'OK' in result) def test_find_artist(self): result = self.dispatcher.handle_request(u'find "artist" "what"') self.assert_(u'OK' in result) def test_find_artist_without_quotes(self): result = self.dispatcher.handle_request(u'find artist "what"') self.assert_(u'OK' in result) def test_find_title(self): result = self.dispatcher.handle_request(u'find "title" "what"') self.assert_(u'OK' in result) def test_find_title_without_quotes(self): result = self.dispatcher.handle_request(u'find title "what"') self.assert_(u'OK' in result) def test_find_date(self): 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.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.dispatcher.handle_request(u'find Date "2005"') self.assert_(u'OK' in result) def test_find_else_should_fail(self): 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.dispatcher.handle_request( u'find album "album_what" artist "artist_what"') self.assert_(u'OK' in result)