Add empty handlers for the majority of the MPD protocol

mopidy/handler.py

@@ -30,14 +30,36 @@ class MpdHandler(object):
                 groups = matches.groupdict()
                 return _request_handlers[pattern](self, **groups)
         logger.warning(u'Unhandled request: %s', request)
+        return False
 
     def register_backend(self, backend):
         self.backend = backend
 
+    @register(r'^clearerror$')
+    def _clearerror(self):
+        pass # TODO
+
+    @register(r'^consume (?P<state>[01])$')
+    def _consume(self, state):
+        state = int(state)
+        if state:
+            pass # TODO
+        else:
+            pass # TODO
+
+    @register(r'^crossfade (?P<seconds>\d+)$')
+    def _crossfade(self, seconds):
+        seconds = int(seconds)
+        pass # TODO
+
     @register(r'^currentsong$')
     def _currentsong(self):
         return self.backend.current_song()
 
+    @register(r'^idle( (?P<subsystems>.+))*$')
+    def _idle(self, subsystems=None):
+        pass # TODO
+
     @register(r'^listplaylists$')
     def _listplaylists(self):
         return self.backend.list_playlists()
@@ -46,16 +68,102 @@ class MpdHandler(object):
     def _lsinfo(self, uri):
         if uri == u'/':
             return self._listplaylists()
-        return None # TODO
+        pass # TODO
+
+    @register(r'^next$')
+    def _next(self):
+        pass # TODO
+
+    @register(r'^pause (?P<state>[01])$')
+    def _pause(self, state):
+        pass # TODO
 
     @register(r'^ping$')
     def _ping(self):
-        return None
+        pass
 
-    @register(r'^plchanges "(?P<version>\d+)"$')
+    @register(r'^play (?P<songpos>.+)$')
+    def _play(self, songpos):
+        pass # TODO
+
+    @register(r'^playid (?P<songid>.+)$')
+    def _playid(self, songid):
+        pass # TODO
+
+    @register(r'^previous$')
+    def _previous(self):
+        pass # TODO
+
+    @register(r'^plchanges (?P<version>\d+)$')
     def _plchanges(self, version):
         return self.backend.playlist_changes(version)
 
+    @register(r'^random (?P<state>[01])$')
+    def _random(self, state):
+        state = int(state)
+        if state:
+            pass # TODO
+        else:
+            pass # TODO
+
+    @register(r'^repeat (?P<state>[01])$')
+    def _repeat(self, state):
+        state = int(state)
+        if state:
+            pass # TODO
+        else:
+            pass # TODO
+
+    @register(r'^replay_gain_mode (?P<mode>(off|track|album))$')
+    def _replay_gain_mode(self, mode):
+        pass # TODO
+
+    @register(r'^replay_gain_status$')
+    def _replay_gain_status(self):
+        return u'off'
+
+    @register(r'^seek (?P<songpos>.+) (?P<seconds>\d+)$')
+    def _seek(self, songpos, seconds):
+        pass # TODO
+
+    @register(r'^seekid (?P<songid>.+) (?P<seconds>\d+)$')
+    def _seekid(self, songid, seconds):
+        pass # TODO
+
+    @register(r'^setvol (?P<volume>-*\d+)$')
+    def _setvol(self, volume):
+        volume = int(volume)
+        if volume < 0:
+            volume = 0
+        if volume > 100:
+            volume = 100
+        pass # TODO
+
+    @register(r'^single (?P<state>[01])$')
+    def _single(self, state):
+        state = int(state)
+        if state:
+            pass # TODO
+        else:
+            pass # TODO
+
+    @register(r'^stats$')
+    def _stats(self):
+        # TODO
+        return {
+            'artists': 0,
+            'albums': 0,
+            'songs': 0,
+            'uptime': 0,
+            'db_playtime': 0,
+            'db_update': 0,
+            'playtime': 0,
+        }
+
+    @register(r'^stop$')
+    def _stop(self):
+        pass # TODO
+
     @register(r'^status$')
     def _status(self):
         return {

tests/handlertest.py

@@ -2,7 +2,7 @@ import unittest
 
 from mopidy import handler
 
-class HandlerTest(unittest.TestCase):
+class RequestHandlerTest(unittest.TestCase):
     def setUp(self):
         self.h = handler.MpdHandler()
 
@@ -17,7 +17,7 @@ class HandlerTest(unittest.TestCase):
 
     def test_handling_unknown_request_returns_none(self):
         result = self.h.handle_request('an unhandled request')
-        self.assert_(result is None)
+        self.assertFalse(result)
 
     def test_handling_known_request(self):
         expected = 'magic'
@@ -25,33 +25,51 @@ class HandlerTest(unittest.TestCase):
         result = self.h.handle_request('known request')
         self.assertEquals(expected, result)
 
+    def test_register_backend(self):
+        expected = 'magic'
+        self.h.register_backend(expected)
+        self.assertEquals(expected, self.h.backend)
+
+
+class StatusHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.h = handler.MpdHandler()
+
+    def test_clearerror(self):
+        result = self.h.handle_request(u'clearerror')
+        self.assert_(result is None)
+
     def test_currentsong(self):
-        result = self.h._currentsong()
+        result = self.h.handle_request(u'currentsong')
         self.assert_(result is None)
 
-    def test_listplaylists(self):
-        result = self.h._listplaylists()
+    def test_idle_without_subsystems(self):
+        result = self.h.handle_request(u'idle')
         self.assert_(result is None)
 
-    def test_lsinfo_for_root_returns_same_as_listplaylists(self):
-        lsinfo_result = self.h._lsinfo('/')
-        listplaylists_result = self.h._listplaylists()
-        self.assertEquals(lsinfo_result, listplaylists_result)
-
-    def test_lsinfo(self):
-        result = self.h._lsinfo('')
+    def test_idle_with_subsystems(self):
+        result = self.h.handle_request(u'idle database playlist')
         self.assert_(result is None)
 
-    def test_ping(self):
-        result = self.h._ping()
-        self.assert_(result is None)
-
-    def test_version(self):
-        result = self.h._plchanges('0')
-        self.assert_(result is None)
+    def test_stats(self):
+        result = self.h.handle_request(u'stats')
+        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(self):
-        result = self.h._status()
+        result = self.h.handle_request(u'status')
         self.assert_('volume' in result)
         self.assert_(int(result['volume']) in xrange(0, 101))
         self.assert_('repeat' in result)
@@ -70,3 +88,209 @@ class HandlerTest(unittest.TestCase):
         self.assert_(int(result['xfade']) >= 0)
         self.assert_('state' in result)
         self.assert_(result['state'] in ('play', 'stop', 'pause'))
+
+
+class PlaybackOptionsHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.h = handler.MpdHandler()
+
+    def test_consume_off(self):
+        result = self.h.handle_request(u'consume 0')
+        self.assert_(result is None)
+
+    def test_consume_on(self):
+        result = self.h.handle_request(u'consume 1')
+        self.assert_(result is None)
+
+    def test_crossfade(self):
+        result = self.h.handle_request(u'crossfade 10')
+        self.assert_(result is None)
+
+    def test_random_off(self):
+        result = self.h.handle_request(u'random 0')
+        self.assert_(result is None)
+
+    def test_random_on(self):
+        result = self.h.handle_request(u'random 1')
+        self.assert_(result is None)
+
+    def test_repeat_off(self):
+        result = self.h.handle_request(u'repeat 0')
+        self.assert_(result is None)
+
+    def test_repeat_on(self):
+        result = self.h.handle_request(u'repeat 1')
+        self.assert_(result is None)
+
+    def test_setvol_below_min(self):
+        result = self.h.handle_request(u'setvol -10')
+        self.assert_(result is None)
+
+    def test_setvol_min(self):
+        result = self.h.handle_request(u'setvol 0')
+        self.assert_(result is None)
+
+    def test_setvol_middle(self):
+        result = self.h.handle_request(u'setvol 50')
+        self.assert_(result is None)
+
+    def test_setvol_max(self):
+        result = self.h.handle_request(u'setvol 100')
+        self.assert_(result is None)
+
+    def test_setvol_above_max(self):
+        result = self.h.handle_request(u'setvol 110')
+        self.assert_(result is None)
+
+    def test_single_off(self):
+        result = self.h.handle_request(u'single 0')
+        self.assert_(result is None)
+
+    def test_single_on(self):
+        result = self.h.handle_request(u'single 1')
+        self.assert_(result is None)
+
+    def test_replay_gain_mode_off(self):
+        result = self.h.handle_request(u'replay_gain_mode off')
+        self.assert_(result is None)
+
+    def test_replay_gain_mode_track(self):
+        result = self.h.handle_request(u'replay_gain_mode track')
+        self.assert_(result is None)
+
+    def test_replay_gain_mode_album(self):
+        result = self.h.handle_request(u'replay_gain_mode album')
+        self.assert_(result is None)
+
+    def test_replay_gain_status_default(self):
+        expected = u'off'
+        result = self.h.handle_request(u'replay_gain_status')
+        self.assertEquals(expected, result)
+
+    def test_replay_gain_status_off(self):
+        expected = u'off'
+        self.h._replay_gain_mode(expected)
+        result = self.h.handle_request(u'replay_gain_status')
+        self.assertEquals(expected, result)
+
+    #def test_replay_gain_status_track(self):
+    #    expected = u'track'
+    #    self.h._replay_gain_mode(expected)
+    #    result = self.h.handle_request(u'replay_gain_status')
+    #    self.assertEquals(expected, result)
+
+    #def test_replay_gain_status_album(self):
+    #    expected = u'album'
+    #    self.h._replay_gain_mode(expected)
+    #    result = self.h.handle_request(u'replay_gain_status')
+    #    self.assertEquals(expected, result)
+
+
+class PlaybackControlHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.h = handler.MpdHandler()
+
+    def test_next(self):
+        result = self.h.handle_request(u'next')
+        self.assert_(result is None)
+
+    def test_pause_off(self):
+        result = self.h.handle_request(u'pause 0')
+        self.assert_(result is None)
+
+    def test_pause_on(self):
+        result = self.h.handle_request(u'pause 1')
+        self.assert_(result is None)
+
+    def test_play(self):
+        result = self.h.handle_request(u'play 0')
+        self.assert_(result is None)
+
+    def test_playid(self):
+        result = self.h.handle_request(u'playid 0')
+        self.assert_(result is None)
+
+    def test_previous(self):
+        result = self.h.handle_request(u'previous')
+        self.assert_(result is None)
+
+    def test_seek(self):
+        result = self.h.handle_request(u'seek 0 30')
+        self.assert_(result is None)
+
+    def test_seekid(self):
+        result = self.h.handle_request(u'seekid 0 30')
+        self.assert_(result is None)
+
+    def test_stop(self):
+        result = self.h.handle_request(u'stop')
+        self.assert_(result is None)
+
+
+class CurrentPlaylistHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.h = handler.MpdHandler()
+
+    pass # TODO
+
+    def test_plchanges(self):
+        result = self.h.handle_request(u'plchanges 0')
+        self.assert_(result is None)
+
+
+class StoredPlaylistsHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.h = handler.MpdHandler()
+
+    def test_listplaylists(self):
+        result = self.h._listplaylists()
+        self.assert_(result is None)
+
+    pass # TODO
+
+
+class MusicDatabaseHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.h = handler.MpdHandler()
+
+    pass # TODO
+
+    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')
+        self.assertEquals(lsinfo_result, listplaylists_result)
+
+    def test_lsinfo(self):
+        result = self.h.handle_request(u'lsinfo ""')
+        self.assert_(result is None)
+
+
+class StickersHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.h = handler.MpdHandler()
+
+    pass # TODO
+
+
+class ConnectionHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.h = handler.MpdHandler()
+
+    pass # TODO
+
+    def test_ping(self):
+        result = self.h.handle_request(u'ping')
+        self.assert_(result is None)
+
+class AudioOutputHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.h = handler.MpdHandler()
+
+    pass # TODO
+
+
+class ReflectionHandlerTest(unittest.TestCase):
+    def setUp(self):
+        self.h = handler.MpdHandler()
+
+    pass # TODO