Switch from mocking the backend to using DummyBackend

tests/frontends/mpris/player_interface_test.py

@@ -3,63 +3,88 @@ import unittest
 
 from pykka.registry import ActorRegistry
 
-from mopidy.backends.base import Backend
+from mopidy.backends.dummy import DummyBackend
 from mopidy.backends.base.playback import PlaybackController
 from mopidy.frontends import mpris
+from mopidy.models import Track
+
+PLAYING = PlaybackController.PLAYING
+PAUSED = PlaybackController.PAUSED
+STOPPED = PlaybackController.STOPPED
 
 class PlayerInterfaceTest(unittest.TestCase):
     def setUp(self):
         mpris.ActorRegistry = mock.Mock(spec=ActorRegistry)
         mpris.MprisObject._connect_to_dbus = mock.Mock()
-        self.backend = mock.Mock(spec=Backend)
+        self.backend = DummyBackend.start().proxy()
         self.mpris_object = mpris.MprisObject()
         self.mpris_object._backend = self.backend
 
-    def test_playback_status_is_playing_when_playing(self):
-        self.backend.playback.state.get.return_value = PlaybackController.PLAYING
+    def tearDown(self):
+        self.backend.stop()
+
+    def test_get_playback_status_is_playing_when_playing(self):
+        self.backend.playback.state = PLAYING
         result = self.mpris_object.Get(mpris.PLAYER_IFACE, 'PlaybackStatus')
         self.assertEqual('Playing', result)
 
-    def test_playback_status_is_paused_when_paused(self):
-        self.backend.playback.state.get.return_value = PlaybackController.PAUSED
+    def test_get_playback_status_is_paused_when_paused(self):
+        self.backend.playback.state = PAUSED
         result = self.mpris_object.Get(mpris.PLAYER_IFACE, 'PlaybackStatus')
         self.assertEqual('Paused', result)
 
-    def test_playback_status_is_stopped_when_stopped(self):
-        self.backend.playback.state.get.return_value = PlaybackController.STOPPED
+    def test_get_playback_status_is_stopped_when_stopped(self):
+        self.backend.playback.state = STOPPED
         result = self.mpris_object.Get(mpris.PLAYER_IFACE, 'PlaybackStatus')
         self.assertEqual('Stopped', result)
 
-    def test_loop_status_is_none_when_not_looping(self):
-        self.backend.playback.repeat.get.return_value = False
-        self.backend.playback.single.get.return_value = False
+    def test_get_loop_status_is_none_when_not_looping(self):
+        self.backend.playback.repeat = False
+        self.backend.playback.single = False
         result = self.mpris_object.Get(mpris.PLAYER_IFACE, 'LoopStatus')
         self.assertEqual('None', result)
 
-    def test_loop_status_is_track_when_looping_a_single_track(self):
-        self.backend.playback.repeat.get.return_value = True
-        self.backend.playback.single.get.return_value = True
+    def test_get_loop_status_is_track_when_looping_a_single_track(self):
+        self.backend.playback.repeat = True
+        self.backend.playback.single = True
         result = self.mpris_object.Get(mpris.PLAYER_IFACE, 'LoopStatus')
         self.assertEqual('Track', result)
 
-    def test_loop_status_is_playlist_when_looping_the_current_playlist(self):
-        self.backend.playback.repeat.get.return_value = True
-        self.backend.playback.single.get.return_value = False
+    def test_get_loop_status_is_playlist_when_looping_the_current_playlist(self):
+        self.backend.playback.repeat = True
+        self.backend.playback.single = False
         result = self.mpris_object.Get(mpris.PLAYER_IFACE, 'LoopStatus')
         self.assertEqual('Playlist', result)
 
-    def test_next_should_call_next_on_backend(self):
+    def test_next_when_playing_should_skip_to_next_track_and_keep_playing(self):
+        self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')])
+        self.backend.playback.play()
+        self.assertEquals(self.backend.playback.current_track.get().uri, 'a')
+        self.assertEquals(self.backend.playback.state.get(), PLAYING)
         self.mpris_object.Next()
-        self.assert_(self.backend.playback.next.called)
+        self.assertEquals(self.backend.playback.current_track.get().uri, 'b')
+        self.assertEquals(self.backend.playback.state.get(), PLAYING)
 
-    def test_pause_should_call_pause_on_backend(self):
+    def test_pause_when_playing_should_pause_playback(self):
+        self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')])
+        self.backend.playback.play()
+        self.assertEquals(self.backend.playback.state.get(), PLAYING)
         self.mpris_object.Pause()
-        self.assert_(self.backend.playback.pause.called)
+        self.assertEquals(self.backend.playback.state.get(), PAUSED)
 
-    def test_previous_should_call_previous_on_backend(self):
+    def test_previous_when_playing_should_skip_to_prev_track_and_keep_playing(self):
+        self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')])
+        self.backend.playback.play()
+        self.backend.playback.next()
+        self.assertEquals(self.backend.playback.current_track.get().uri, 'b')
+        self.assertEquals(self.backend.playback.state.get(), PLAYING)
         self.mpris_object.Previous()
-        self.assert_(self.backend.playback.previous.called)
+        self.assertEquals(self.backend.playback.current_track.get().uri, 'a')
+        self.assertEquals(self.backend.playback.state.get(), PLAYING)
 
-    def test_stop_should_call_stop_on_backend(self):
+    def test_stop_when_playing_should_stop_playback(self):
+        self.backend.current_playlist.append([Track(uri='a'), Track(uri='b')])
+        self.backend.playback.play()
+        self.assertEquals(self.backend.playback.state.get(), PLAYING)
         self.mpris_object.Stop()
-        self.assert_(self.backend.playback.stop.called)
+        self.assertEquals(self.backend.playback.state.get(), STOPPED)