Update tests to use tracks with valid URIs
This commit is contained in:
Stein Magnus Jodal
parent
a8e71afeaf
commit
956655f742
@ -51,9 +51,9 @@ class DummyPlaybackProvider(base.BasePlaybackProvider):
|
||||
return True
|
||||
|
||||
def play(self, track):
|
||||
"""Pass None as track to force failure"""
|
||||
"""Pass a track with URI 'dummy:error' to force failure"""
|
||||
self._time_position = 0
|
||||
return track is not None
|
||||
return track.uri != 'dummy:error'
|
||||
|
||||
def resume(self):
|
||||
return True
|
||||
|
||||
@ -19,14 +19,14 @@ class BackendEventsTest(unittest.TestCase):
|
||||
pykka.ActorRegistry.stop_all()
|
||||
|
||||
def test_pause_sends_track_playback_paused_event(self, send):
|
||||
self.core.current_playlist.add(Track(uri='a'))
|
||||
self.core.current_playlist.add(Track(uri='dummy:a'))
|
||||
self.core.playback.play().get()
|
||||
send.reset_mock()
|
||||
self.core.playback.pause().get()
|
||||
self.assertEqual(send.call_args[0][0], 'track_playback_paused')
|
||||
|
||||
def test_resume_sends_track_playback_resumed(self, send):
|
||||
self.core.current_playlist.add(Track(uri='a'))
|
||||
self.core.current_playlist.add(Track(uri='dummy:a'))
|
||||
self.core.playback.play()
|
||||
self.core.playback.pause().get()
|
||||
send.reset_mock()
|
||||
@ -34,20 +34,20 @@ class BackendEventsTest(unittest.TestCase):
|
||||
self.assertEqual(send.call_args[0][0], 'track_playback_resumed')
|
||||
|
||||
def test_play_sends_track_playback_started_event(self, send):
|
||||
self.core.current_playlist.add(Track(uri='a'))
|
||||
self.core.current_playlist.add(Track(uri='dummy:a'))
|
||||
send.reset_mock()
|
||||
self.core.playback.play().get()
|
||||
self.assertEqual(send.call_args[0][0], 'track_playback_started')
|
||||
|
||||
def test_stop_sends_track_playback_ended_event(self, send):
|
||||
self.core.current_playlist.add(Track(uri='a'))
|
||||
self.core.current_playlist.add(Track(uri='dummy:a'))
|
||||
self.core.playback.play().get()
|
||||
send.reset_mock()
|
||||
self.core.playback.stop().get()
|
||||
self.assertEqual(send.call_args_list[0][0][0], 'track_playback_ended')
|
||||
|
||||
def test_seek_sends_seeked_event(self, send):
|
||||
self.core.current_playlist.add(Track(uri='a', length=40000))
|
||||
self.core.current_playlist.add(Track(uri='dummy:a', length=40000))
|
||||
self.core.playback.play().get()
|
||||
send.reset_mock()
|
||||
self.core.playback.seek(1000).get()
|
||||
|
||||
@ -166,7 +166,7 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_pause_off(self):
|
||||
self.core.current_playlist.append([Track()])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
|
||||
self.sendRequest(u'play "0"')
|
||||
self.sendRequest(u'pause "1"')
|
||||
@ -175,7 +175,7 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_pause_on(self):
|
||||
self.core.current_playlist.append([Track()])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
|
||||
self.sendRequest(u'play "0"')
|
||||
self.sendRequest(u'pause "1"')
|
||||
@ -183,7 +183,7 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_pause_toggle(self):
|
||||
self.core.current_playlist.append([Track()])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
|
||||
self.sendRequest(u'play "0"')
|
||||
self.assertEqual(PLAYING, self.core.playback.state.get())
|
||||
@ -198,22 +198,21 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_play_without_pos(self):
|
||||
self.core.current_playlist.append([Track()])
|
||||
self.core.playback.state = PAUSED
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
|
||||
self.sendRequest(u'play')
|
||||
self.assertEqual(PLAYING, self.core.playback.state.get())
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_play_with_pos(self):
|
||||
self.core.current_playlist.append([Track()])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
|
||||
self.sendRequest(u'play "0"')
|
||||
self.assertEqual(PLAYING, self.core.playback.state.get())
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_play_with_pos_without_quotes(self):
|
||||
self.core.current_playlist.append([Track()])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
|
||||
self.sendRequest(u'play 0')
|
||||
self.assertEqual(PLAYING, self.core.playback.state.get())
|
||||
@ -228,15 +227,22 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
|
||||
def test_play_minus_one_plays_first_in_playlist_if_no_current_track(self):
|
||||
self.assertEqual(self.core.playback.current_track.get(), None)
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'),
|
||||
Track(uri='dummy:b'),
|
||||
])
|
||||
|
||||
self.sendRequest(u'play "-1"')
|
||||
self.assertEqual(PLAYING, self.core.playback.state.get())
|
||||
self.assertEqual('a', self.core.playback.current_track.get().uri)
|
||||
self.assertEqual('dummy:a',
|
||||
self.core.playback.current_track.get().uri)
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_play_minus_one_plays_current_track_if_current_track_is_set(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'),
|
||||
Track(uri='dummy:b'),
|
||||
])
|
||||
self.assertEqual(self.core.playback.current_track.get(), None)
|
||||
self.core.playback.play()
|
||||
self.core.playback.next()
|
||||
@ -245,7 +251,8 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
|
||||
self.sendRequest(u'play "-1"')
|
||||
self.assertEqual(PLAYING, self.core.playback.state.get())
|
||||
self.assertEqual('b', self.core.playback.current_track.get().uri)
|
||||
self.assertEqual('dummy:b',
|
||||
self.core.playback.current_track.get().uri)
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_play_minus_one_on_empty_playlist_does_not_ack(self):
|
||||
@ -257,7 +264,8 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_play_minus_is_ignored_if_playing(self):
|
||||
self.core.current_playlist.append([Track(length=40000)])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.seek(30000)
|
||||
self.assertGreaterEqual(
|
||||
self.core.playback.time_position.get(), 30000)
|
||||
@ -270,7 +278,8 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_play_minus_one_resumes_if_paused(self):
|
||||
self.core.current_playlist.append([Track(length=40000)])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.seek(30000)
|
||||
self.assertGreaterEqual(
|
||||
self.core.playback.time_position.get(), 30000)
|
||||
@ -285,14 +294,14 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_playid(self):
|
||||
self.core.current_playlist.append([Track()])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
|
||||
self.sendRequest(u'playid "0"')
|
||||
self.assertEqual(PLAYING, self.core.playback.state.get())
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_playid_without_quotes(self):
|
||||
self.core.current_playlist.append([Track()])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
|
||||
self.sendRequest(u'playid 0')
|
||||
self.assertEqual(PLAYING, self.core.playback.state.get())
|
||||
@ -300,15 +309,22 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
|
||||
def test_playid_minus_1_plays_first_in_playlist_if_no_current_track(self):
|
||||
self.assertEqual(self.core.playback.current_track.get(), None)
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'),
|
||||
Track(uri='dummy:b'),
|
||||
])
|
||||
|
||||
self.sendRequest(u'playid "-1"')
|
||||
self.assertEqual(PLAYING, self.core.playback.state.get())
|
||||
self.assertEqual('a', self.core.playback.current_track.get().uri)
|
||||
self.assertEqual('dummy:a',
|
||||
self.core.playback.current_track.get().uri)
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_playid_minus_1_plays_current_track_if_current_track_is_set(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'),
|
||||
Track(uri='dummy:b'),
|
||||
])
|
||||
self.assertEqual(self.core.playback.current_track.get(), None)
|
||||
self.core.playback.play()
|
||||
self.core.playback.next()
|
||||
@ -317,7 +333,8 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
|
||||
self.sendRequest(u'playid "-1"')
|
||||
self.assertEqual(PLAYING, self.core.playback.state.get())
|
||||
self.assertEqual('b', self.core.playback.current_track.get().uri)
|
||||
self.assertEqual('dummy:b',
|
||||
self.core.playback.current_track.get().uri)
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_playid_minus_one_on_empty_playlist_does_not_ack(self):
|
||||
@ -329,7 +346,7 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_playid_minus_is_ignored_if_playing(self):
|
||||
self.core.current_playlist.append([Track(length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.seek(30000)
|
||||
self.assertGreaterEqual(
|
||||
self.core.playback.time_position.get(), 30000)
|
||||
@ -342,7 +359,7 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_playid_minus_one_resumes_if_paused(self):
|
||||
self.core.current_playlist.append([Track(length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.seek(30000)
|
||||
self.assertGreaterEqual(
|
||||
self.core.playback.time_position.get(), 30000)
|
||||
@ -357,7 +374,7 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_playid_which_does_not_exist(self):
|
||||
self.core.current_playlist.append([Track()])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
|
||||
self.sendRequest(u'playid "12345"')
|
||||
self.assertInResponse(u'ACK [50@0] {playid} No such song')
|
||||
@ -367,7 +384,7 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_seek(self):
|
||||
self.core.current_playlist.append([Track(length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
|
||||
self.sendRequest(u'seek "0"')
|
||||
self.sendRequest(u'seek "0" "30"')
|
||||
@ -375,16 +392,16 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_seek_with_songpos(self):
|
||||
seek_track = Track(uri='2', length=40000)
|
||||
seek_track = Track(uri='dummy:2', length=40000)
|
||||
self.core.current_playlist.append(
|
||||
[Track(uri='1', length=40000), seek_track])
|
||||
[Track(uri='dummy:1', length=40000), seek_track])
|
||||
|
||||
self.sendRequest(u'seek "1" "30"')
|
||||
self.assertEqual(self.core.playback.current_track.get(), seek_track)
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_seek_without_quotes(self):
|
||||
self.core.current_playlist.append([Track(length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
|
||||
self.sendRequest(u'seek 0')
|
||||
self.sendRequest(u'seek 0 30')
|
||||
@ -393,16 +410,16 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase):
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_seekid(self):
|
||||
self.core.current_playlist.append([Track(length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.sendRequest(u'seekid "0" "30"')
|
||||
self.assertGreaterEqual(
|
||||
self.core.playback.time_position.get(), 30000)
|
||||
self.assertInResponse(u'OK')
|
||||
|
||||
def test_seekid_with_cpid(self):
|
||||
seek_track = Track(uri='2', length=40000)
|
||||
seek_track = Track(uri='dummy:2', length=40000)
|
||||
self.core.current_playlist.append(
|
||||
[Track(length=40000), seek_track])
|
||||
[Track(uri='dummy:1', length=40000), seek_track])
|
||||
|
||||
self.sendRequest(u'seekid "1" "30"')
|
||||
self.assertEqual(1, self.core.playback.current_cpid.get())
|
||||
|
||||
@ -17,22 +17,32 @@ class IssueGH17RegressionTest(protocol.BaseTestCase):
|
||||
"""
|
||||
def test(self):
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='a'), Track(uri='b'), None,
|
||||
Track(uri='d'), Track(uri='e'), Track(uri='f')])
|
||||
Track(uri='dummy:a'),
|
||||
Track(uri='dummy:b'),
|
||||
Track(uri='dummy:error'),
|
||||
Track(uri='dummy:d'),
|
||||
Track(uri='dummy:e'),
|
||||
Track(uri='dummy:f'),
|
||||
])
|
||||
random.seed(1) # Playlist order: abcfde
|
||||
|
||||
self.sendRequest(u'play')
|
||||
self.assertEquals('a', self.core.playback.current_track.get().uri)
|
||||
self.assertEquals('dummy:a',
|
||||
self.core.playback.current_track.get().uri)
|
||||
self.sendRequest(u'random "1"')
|
||||
self.sendRequest(u'next')
|
||||
self.assertEquals('b', self.core.playback.current_track.get().uri)
|
||||
self.assertEquals('dummy:b',
|
||||
self.core.playback.current_track.get().uri)
|
||||
self.sendRequest(u'next')
|
||||
# Should now be at track 'c', but playback fails and it skips ahead
|
||||
self.assertEquals('f', self.core.playback.current_track.get().uri)
|
||||
self.assertEquals('dummy:f',
|
||||
self.core.playback.current_track.get().uri)
|
||||
self.sendRequest(u'next')
|
||||
self.assertEquals('d', self.core.playback.current_track.get().uri)
|
||||
self.assertEquals('dummy:d',
|
||||
self.core.playback.current_track.get().uri)
|
||||
self.sendRequest(u'next')
|
||||
self.assertEquals('e', self.core.playback.current_track.get().uri)
|
||||
self.assertEquals('dummy:e',
|
||||
self.core.playback.current_track.get().uri)
|
||||
|
||||
|
||||
class IssueGH18RegressionTest(protocol.BaseTestCase):
|
||||
@ -48,8 +58,8 @@ class IssueGH18RegressionTest(protocol.BaseTestCase):
|
||||
|
||||
def test(self):
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='a'), Track(uri='b'), Track(uri='c'),
|
||||
Track(uri='d'), Track(uri='e'), Track(uri='f')])
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b'), Track(uri='dummy:c'),
|
||||
Track(uri='dummy:d'), Track(uri='dummy:e'), Track(uri='dummy:f')])
|
||||
random.seed(1)
|
||||
|
||||
self.sendRequest(u'play')
|
||||
@ -84,8 +94,8 @@ class IssueGH22RegressionTest(protocol.BaseTestCase):
|
||||
|
||||
def test(self):
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='a'), Track(uri='b'), Track(uri='c'),
|
||||
Track(uri='d'), Track(uri='e'), Track(uri='f')])
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b'), Track(uri='dummy:c'),
|
||||
Track(uri='dummy:d'), Track(uri='dummy:e'), Track(uri='dummy:f')])
|
||||
random.seed(1)
|
||||
|
||||
self.sendRequest(u'play')
|
||||
@ -113,8 +123,8 @@ class IssueGH69RegressionTest(protocol.BaseTestCase):
|
||||
def test(self):
|
||||
self.core.stored_playlists.create('foo')
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='a'), Track(uri='b'), Track(uri='c'),
|
||||
Track(uri='d'), Track(uri='e'), Track(uri='f')])
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b'), Track(uri='dummy:c'),
|
||||
Track(uri='dummy:d'), Track(uri='dummy:e'), Track(uri='dummy:f')])
|
||||
|
||||
self.sendRequest(u'play')
|
||||
self.sendRequest(u'stop')
|
||||
|
||||
@ -129,21 +129,21 @@ class StatusHandlerTest(unittest.TestCase):
|
||||
self.assertEqual(result['state'], 'pause')
|
||||
|
||||
def test_status_method_when_playlist_loaded_contains_song(self):
|
||||
self.core.current_playlist.append([Track()])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
self.core.playback.play()
|
||||
result = dict(status.status(self.context))
|
||||
self.assertIn('song', result)
|
||||
self.assertGreaterEqual(int(result['song']), 0)
|
||||
|
||||
def test_status_method_when_playlist_loaded_contains_cpid_as_songid(self):
|
||||
self.core.current_playlist.append([Track()])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
self.core.playback.play()
|
||||
result = dict(status.status(self.context))
|
||||
self.assertIn('songid', result)
|
||||
self.assertEqual(int(result['songid']), 0)
|
||||
|
||||
def test_status_method_when_playing_contains_time_with_no_length(self):
|
||||
self.core.current_playlist.append([Track(length=None)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=None)])
|
||||
self.core.playback.play()
|
||||
result = dict(status.status(self.context))
|
||||
self.assertIn('time', result)
|
||||
@ -153,7 +153,7 @@ class StatusHandlerTest(unittest.TestCase):
|
||||
self.assertLessEqual(position, total)
|
||||
|
||||
def test_status_method_when_playing_contains_time_with_length(self):
|
||||
self.core.current_playlist.append([Track(length=10000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=10000)])
|
||||
self.core.playback.play()
|
||||
result = dict(status.status(self.context))
|
||||
self.assertIn('time', result)
|
||||
@ -163,7 +163,7 @@ class StatusHandlerTest(unittest.TestCase):
|
||||
self.assertLessEqual(position, total)
|
||||
|
||||
def test_status_method_when_playing_contains_elapsed(self):
|
||||
self.core.current_playlist.append([Track(length=60000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=60000)])
|
||||
self.core.playback.play()
|
||||
self.core.playback.pause()
|
||||
self.core.playback.seek(59123)
|
||||
@ -172,7 +172,7 @@ class StatusHandlerTest(unittest.TestCase):
|
||||
self.assertEqual(result['elapsed'], '59.123')
|
||||
|
||||
def test_status_method_when_starting_playing_contains_elapsed_zero(self):
|
||||
self.core.current_playlist.append([Track(length=10000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=10000)])
|
||||
self.core.playback.play()
|
||||
self.core.playback.pause()
|
||||
result = dict(status.status(self.context))
|
||||
@ -180,7 +180,7 @@ class StatusHandlerTest(unittest.TestCase):
|
||||
self.assertEqual(result['elapsed'], '0.000')
|
||||
|
||||
def test_status_method_when_playing_contains_bitrate(self):
|
||||
self.core.current_playlist.append([Track(bitrate=320)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', bitrate=320)])
|
||||
self.core.playback.play()
|
||||
result = dict(status.status(self.context))
|
||||
self.assertIn('bitrate', result)
|
||||
|
||||
@ -69,23 +69,23 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
self.core.playback.repeat = True
|
||||
self.core.playback.single = True
|
||||
self.mpris.Set(objects.PLAYER_IFACE, 'LoopStatus', 'None')
|
||||
self.assertEquals(self.core.playback.repeat.get(), True)
|
||||
self.assertEquals(self.core.playback.single.get(), True)
|
||||
self.assertEqual(self.core.playback.repeat.get(), True)
|
||||
self.assertEqual(self.core.playback.single.get(), True)
|
||||
|
||||
def test_set_loop_status_to_none_unsets_repeat_and_single(self):
|
||||
self.mpris.Set(objects.PLAYER_IFACE, 'LoopStatus', 'None')
|
||||
self.assertEquals(self.core.playback.repeat.get(), False)
|
||||
self.assertEquals(self.core.playback.single.get(), False)
|
||||
self.assertEqual(self.core.playback.repeat.get(), False)
|
||||
self.assertEqual(self.core.playback.single.get(), False)
|
||||
|
||||
def test_set_loop_status_to_track_sets_repeat_and_single(self):
|
||||
self.mpris.Set(objects.PLAYER_IFACE, 'LoopStatus', 'Track')
|
||||
self.assertEquals(self.core.playback.repeat.get(), True)
|
||||
self.assertEquals(self.core.playback.single.get(), True)
|
||||
self.assertEqual(self.core.playback.repeat.get(), True)
|
||||
self.assertEqual(self.core.playback.single.get(), True)
|
||||
|
||||
def test_set_loop_status_to_playlists_sets_repeat_and_not_single(self):
|
||||
self.mpris.Set(objects.PLAYER_IFACE, 'LoopStatus', 'Playlist')
|
||||
self.assertEquals(self.core.playback.repeat.get(), True)
|
||||
self.assertEquals(self.core.playback.single.get(), False)
|
||||
self.assertEqual(self.core.playback.repeat.get(), True)
|
||||
self.assertEqual(self.core.playback.single.get(), False)
|
||||
|
||||
def test_get_rate_is_greater_or_equal_than_minimum_rate(self):
|
||||
rate = self.mpris.Get(objects.PLAYER_IFACE, 'Rate')
|
||||
@ -99,18 +99,20 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
def test_set_rate_is_ignored_if_can_control_is_false(self):
|
||||
self.mpris.get_CanControl = lambda *_: False
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.Set(objects.PLAYER_IFACE, 'Rate', 0)
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
def test_set_rate_to_zero_pauses_playback(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.Set(objects.PLAYER_IFACE, 'Rate', 0)
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
|
||||
def test_get_shuffle_returns_true_if_random_is_active(self):
|
||||
self.core.playback.random = True
|
||||
@ -143,37 +145,37 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
def test_get_metadata_has_trackid_even_when_no_current_track(self):
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata')
|
||||
self.assertIn('mpris:trackid', result.keys())
|
||||
self.assertEquals(result['mpris:trackid'], '')
|
||||
self.assertEqual(result['mpris:trackid'], '')
|
||||
|
||||
def test_get_metadata_has_trackid_based_on_cpid(self):
|
||||
self.core.current_playlist.append([Track(uri='a')])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
self.core.playback.play()
|
||||
(cpid, track) = self.core.playback.current_cp_track.get()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata')
|
||||
self.assertIn('mpris:trackid', result.keys())
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
result['mpris:trackid'], '/com/mopidy/track/%d' % cpid)
|
||||
|
||||
def test_get_metadata_has_track_length(self):
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata')
|
||||
self.assertIn('mpris:length', result.keys())
|
||||
self.assertEquals(result['mpris:length'], 40000000)
|
||||
self.assertEqual(result['mpris:length'], 40000000)
|
||||
|
||||
def test_get_metadata_has_track_uri(self):
|
||||
self.core.current_playlist.append([Track(uri='a')])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
self.core.playback.play()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata')
|
||||
self.assertIn('xesam:url', result.keys())
|
||||
self.assertEquals(result['xesam:url'], 'a')
|
||||
self.assertEqual(result['xesam:url'], 'dummy:a')
|
||||
|
||||
def test_get_metadata_has_track_title(self):
|
||||
self.core.current_playlist.append([Track(name='a')])
|
||||
self.core.playback.play()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata')
|
||||
self.assertIn('xesam:title', result.keys())
|
||||
self.assertEquals(result['xesam:title'], 'a')
|
||||
self.assertEqual(result['xesam:title'], 'a')
|
||||
|
||||
def test_get_metadata_has_track_artists(self):
|
||||
self.core.current_playlist.append([Track(artists=[
|
||||
@ -181,14 +183,14 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
self.core.playback.play()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata')
|
||||
self.assertIn('xesam:artist', result.keys())
|
||||
self.assertEquals(result['xesam:artist'], ['a', 'b'])
|
||||
self.assertEqual(result['xesam:artist'], ['a', 'b'])
|
||||
|
||||
def test_get_metadata_has_track_album(self):
|
||||
self.core.current_playlist.append([Track(album=Album(name='a'))])
|
||||
self.core.playback.play()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata')
|
||||
self.assertIn('xesam:album', result.keys())
|
||||
self.assertEquals(result['xesam:album'], 'a')
|
||||
self.assertEqual(result['xesam:album'], 'a')
|
||||
|
||||
def test_get_metadata_has_track_album_artists(self):
|
||||
self.core.current_playlist.append([Track(album=Album(artists=[
|
||||
@ -196,53 +198,53 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
self.core.playback.play()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata')
|
||||
self.assertIn('xesam:albumArtist', result.keys())
|
||||
self.assertEquals(result['xesam:albumArtist'], ['a', 'b'])
|
||||
self.assertEqual(result['xesam:albumArtist'], ['a', 'b'])
|
||||
|
||||
def test_get_metadata_has_track_number_in_album(self):
|
||||
self.core.current_playlist.append([Track(track_no=7)])
|
||||
self.core.playback.play()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Metadata')
|
||||
self.assertIn('xesam:trackNumber', result.keys())
|
||||
self.assertEquals(result['xesam:trackNumber'], 7)
|
||||
self.assertEqual(result['xesam:trackNumber'], 7)
|
||||
|
||||
def test_get_volume_should_return_volume_between_zero_and_one(self):
|
||||
self.core.playback.volume = None
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Volume')
|
||||
self.assertEquals(result, 0)
|
||||
self.assertEqual(result, 0)
|
||||
|
||||
self.core.playback.volume = 0
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Volume')
|
||||
self.assertEquals(result, 0)
|
||||
self.assertEqual(result, 0)
|
||||
|
||||
self.core.playback.volume = 50
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Volume')
|
||||
self.assertEquals(result, 0.5)
|
||||
self.assertEqual(result, 0.5)
|
||||
|
||||
self.core.playback.volume = 100
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'Volume')
|
||||
self.assertEquals(result, 1)
|
||||
self.assertEqual(result, 1)
|
||||
|
||||
def test_set_volume_is_ignored_if_can_control_is_false(self):
|
||||
self.mpris.get_CanControl = lambda *_: False
|
||||
self.core.playback.volume = 0
|
||||
self.mpris.Set(objects.PLAYER_IFACE, 'Volume', 1.0)
|
||||
self.assertEquals(self.core.playback.volume.get(), 0)
|
||||
self.assertEqual(self.core.playback.volume.get(), 0)
|
||||
|
||||
def test_set_volume_to_one_should_set_mixer_volume_to_100(self):
|
||||
self.mpris.Set(objects.PLAYER_IFACE, 'Volume', 1.0)
|
||||
self.assertEquals(self.core.playback.volume.get(), 100)
|
||||
self.assertEqual(self.core.playback.volume.get(), 100)
|
||||
|
||||
def test_set_volume_to_anything_above_one_sets_mixer_volume_to_100(self):
|
||||
self.mpris.Set(objects.PLAYER_IFACE, 'Volume', 2.0)
|
||||
self.assertEquals(self.core.playback.volume.get(), 100)
|
||||
self.assertEqual(self.core.playback.volume.get(), 100)
|
||||
|
||||
def test_set_volume_to_anything_not_a_number_does_not_change_volume(self):
|
||||
self.core.playback.volume = 10
|
||||
self.mpris.Set(objects.PLAYER_IFACE, 'Volume', None)
|
||||
self.assertEquals(self.core.playback.volume.get(), 10)
|
||||
self.assertEqual(self.core.playback.volume.get(), 10)
|
||||
|
||||
def test_get_position_returns_time_position_in_microseconds(self):
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
self.core.playback.seek(10000)
|
||||
result_in_microseconds = self.mpris.Get(
|
||||
@ -254,7 +256,7 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
result_in_microseconds = self.mpris.Get(
|
||||
objects.PLAYER_IFACE, 'Position')
|
||||
result_in_milliseconds = result_in_microseconds // 1000
|
||||
self.assertEquals(result_in_milliseconds, 0)
|
||||
self.assertEqual(result_in_milliseconds, 0)
|
||||
|
||||
def test_get_minimum_rate_is_one_or_less(self):
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'MinimumRate')
|
||||
@ -266,14 +268,15 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
def test_can_go_next_is_true_if_can_control_and_other_next_track(self):
|
||||
self.mpris.get_CanControl = lambda *_: True
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoNext')
|
||||
self.assertTrue(result)
|
||||
|
||||
def test_can_go_next_is_false_if_next_track_is_the_same(self):
|
||||
self.mpris.get_CanControl = lambda *_: True
|
||||
self.core.current_playlist.append([Track(uri='a')])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
self.core.playback.repeat = True
|
||||
self.core.playback.play()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoNext')
|
||||
@ -281,14 +284,16 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
def test_can_go_next_is_false_if_can_control_is_false(self):
|
||||
self.mpris.get_CanControl = lambda *_: False
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoNext')
|
||||
self.assertFalse(result)
|
||||
|
||||
def test_can_go_previous_is_true_if_can_control_and_previous_track(self):
|
||||
self.mpris.get_CanControl = lambda *_: True
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.next()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoPrevious')
|
||||
@ -296,7 +301,7 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
def test_can_go_previous_is_false_if_previous_track_is_the_same(self):
|
||||
self.mpris.get_CanControl = lambda *_: True
|
||||
self.core.current_playlist.append([Track(uri='a')])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
self.core.playback.repeat = True
|
||||
self.core.playback.play()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoPrevious')
|
||||
@ -304,7 +309,8 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
def test_can_go_previous_is_false_if_can_control_is_false(self):
|
||||
self.mpris.get_CanControl = lambda *_: False
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.next()
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoPrevious')
|
||||
@ -312,7 +318,7 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
def test_can_play_is_true_if_can_control_and_current_track(self):
|
||||
self.mpris.get_CanControl = lambda *_: True
|
||||
self.core.current_playlist.append([Track(uri='a')])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a')])
|
||||
self.core.playback.play()
|
||||
self.assertTrue(self.core.playback.current_track.get())
|
||||
result = self.mpris.Get(objects.PLAYER_IFACE, 'CanPlay')
|
||||
@ -355,220 +361,242 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
def test_next_is_ignored_if_can_go_next_is_false(self):
|
||||
self.mpris.get_CanGoNext = lambda *_: False
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
self.mpris.Next()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
|
||||
def test_next_when_playing_skips_to_next_track_and_keep_playing(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.Next()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'b')
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:b')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
def test_next_when_at_end_of_list_should_stop_playback(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.next()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'b')
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:b')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.Next()
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
|
||||
def test_next_when_paused_should_skip_to_next_track_and_stay_paused(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.pause()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
self.mpris.Next()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'b')
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:b')
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
|
||||
def test_next_when_stopped_skips_to_next_track_and_stay_stopped(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.stop()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
self.mpris.Next()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'b')
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:b')
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
|
||||
def test_previous_is_ignored_if_can_go_previous_is_false(self):
|
||||
self.mpris.get_CanGoPrevious = lambda *_: False
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.next()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'b')
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:b')
|
||||
self.mpris.Previous()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'b')
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:b')
|
||||
|
||||
def test_previous_when_playing_skips_to_prev_track_and_keep_playing(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.next()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'b')
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:b')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.Previous()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
def test_previous_when_at_start_of_list_should_stop_playback(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.Previous()
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
|
||||
def test_previous_when_paused_skips_to_previous_track_and_pause(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.next()
|
||||
self.core.playback.pause()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'b')
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:b')
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
self.mpris.Previous()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
|
||||
def test_previous_when_stopped_skips_to_previous_track_and_stops(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.next()
|
||||
self.core.playback.stop()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'b')
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:b')
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
self.mpris.Previous()
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
|
||||
def test_pause_is_ignored_if_can_pause_is_false(self):
|
||||
self.mpris.get_CanPause = lambda *_: False
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.Pause()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
def test_pause_when_playing_should_pause_playback(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.Pause()
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
|
||||
def test_pause_when_paused_has_no_effect(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.pause()
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
self.mpris.Pause()
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
|
||||
def test_playpause_is_ignored_if_can_pause_is_false(self):
|
||||
self.mpris.get_CanPause = lambda *_: False
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.PlayPause()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
def test_playpause_when_playing_should_pause_playback(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.PlayPause()
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
|
||||
def test_playpause_when_paused_should_resume_playback(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.pause()
|
||||
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
at_pause = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(at_pause, 0)
|
||||
|
||||
self.mpris.PlayPause()
|
||||
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
after_pause = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(after_pause, at_pause)
|
||||
|
||||
def test_playpause_when_stopped_should_start_playback(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
self.mpris.PlayPause()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
def test_stop_is_ignored_if_can_control_is_false(self):
|
||||
self.mpris.get_CanControl = lambda *_: False
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.Stop()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
def test_stop_when_playing_should_stop_playback(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.mpris.Stop()
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
|
||||
def test_stop_when_paused_should_stop_playback(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.pause()
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
self.mpris.Stop()
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
|
||||
def test_play_is_ignored_if_can_play_is_false(self):
|
||||
self.mpris.get_CanPlay = lambda *_: False
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
self.mpris.Play()
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
|
||||
def test_play_when_stopped_starts_playback(self):
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
self.mpris.Play()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
def test_play_after_pause_resumes_from_same_position(self):
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
|
||||
before_pause = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(before_pause, 0)
|
||||
|
||||
self.mpris.Pause()
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
at_pause = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(at_pause, before_pause)
|
||||
|
||||
self.mpris.Play()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
after_pause = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(after_pause, at_pause)
|
||||
|
||||
def test_play_when_there_is_no_track_has_no_effect(self):
|
||||
self.core.current_playlist.clear()
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
self.mpris.Play()
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
|
||||
def test_seek_is_ignored_if_can_seek_is_false(self):
|
||||
self.mpris.get_CanSeek = lambda *_: False
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
|
||||
before_seek = self.core.playback.time_position.get()
|
||||
@ -584,7 +612,7 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
self.assertLess(after_seek, before_seek + milliseconds_to_seek)
|
||||
|
||||
def test_seek_seeks_given_microseconds_forward_in_the_current_track(self):
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
|
||||
before_seek = self.core.playback.time_position.get()
|
||||
@ -595,13 +623,13 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
self.mpris.Seek(microseconds_to_seek)
|
||||
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
after_seek = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(after_seek, before_seek + milliseconds_to_seek)
|
||||
|
||||
def test_seek_seeks_given_microseconds_backward_if_negative(self):
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
self.core.playback.seek(20000)
|
||||
|
||||
@ -613,14 +641,14 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
self.mpris.Seek(microseconds_to_seek)
|
||||
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
after_seek = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(after_seek, before_seek + milliseconds_to_seek)
|
||||
self.assertLess(after_seek, before_seek)
|
||||
|
||||
def test_seek_seeks_to_start_of_track_if_new_position_is_negative(self):
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
self.core.playback.seek(20000)
|
||||
|
||||
@ -632,7 +660,7 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
self.mpris.Seek(microseconds_to_seek)
|
||||
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
after_seek = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(after_seek, before_seek + milliseconds_to_seek)
|
||||
@ -641,23 +669,23 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
def test_seek_skips_to_next_track_if_new_position_gt_track_length(self):
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='a', length=40000),
|
||||
Track(uri='b')])
|
||||
Track(uri='dummy:a', length=40000),
|
||||
Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.seek(20000)
|
||||
|
||||
before_seek = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(before_seek, 20000)
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
|
||||
milliseconds_to_seek = 50000
|
||||
microseconds_to_seek = milliseconds_to_seek * 1000
|
||||
|
||||
self.mpris.Seek(microseconds_to_seek)
|
||||
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'b')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:b')
|
||||
|
||||
after_seek = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(after_seek, 0)
|
||||
@ -665,7 +693,7 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
def test_set_position_is_ignored_if_can_seek_is_false(self):
|
||||
self.mpris.get_CanSeek = lambda *_: False
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
|
||||
before_set_position = self.core.playback.time_position.get()
|
||||
@ -683,12 +711,12 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
self.assertLess(after_set_position, position_to_set_in_millisec)
|
||||
|
||||
def test_set_position_sets_the_current_track_position_in_microsecs(self):
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
|
||||
before_set_position = self.core.playback.time_position.get()
|
||||
self.assertLessEqual(before_set_position, 5000)
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
track_id = '/com/mopidy/track/0'
|
||||
|
||||
@ -697,22 +725,22 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
self.mpris.SetPosition(track_id, position_to_set_in_microsec)
|
||||
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
|
||||
after_set_position = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(
|
||||
after_set_position, position_to_set_in_millisec)
|
||||
|
||||
def test_set_position_does_nothing_if_the_position_is_negative(self):
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
self.core.playback.seek(20000)
|
||||
|
||||
before_set_position = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(before_set_position, 20000)
|
||||
self.assertLessEqual(before_set_position, 25000)
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
|
||||
track_id = '/com/mopidy/track/0'
|
||||
|
||||
@ -723,19 +751,19 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
after_set_position = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(after_set_position, before_set_position)
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
|
||||
def test_set_position_does_nothing_if_position_is_gt_track_length(self):
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
self.core.playback.seek(20000)
|
||||
|
||||
before_set_position = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(before_set_position, 20000)
|
||||
self.assertLessEqual(before_set_position, 25000)
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
|
||||
track_id = 'a'
|
||||
|
||||
@ -746,19 +774,19 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
after_set_position = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(after_set_position, before_set_position)
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
|
||||
def test_set_position_is_noop_if_track_id_isnt_current_track(self):
|
||||
self.core.current_playlist.append([Track(uri='a', length=40000)])
|
||||
self.core.current_playlist.append([Track(uri='dummy:a', length=40000)])
|
||||
self.core.playback.play()
|
||||
self.core.playback.seek(20000)
|
||||
|
||||
before_set_position = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(before_set_position, 20000)
|
||||
self.assertLessEqual(before_set_position, 25000)
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
|
||||
track_id = 'b'
|
||||
|
||||
@ -769,15 +797,15 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
|
||||
after_set_position = self.core.playback.time_position.get()
|
||||
self.assertGreaterEqual(after_set_position, before_set_position)
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
|
||||
def test_open_uri_is_ignored_if_can_play_is_false(self):
|
||||
self.mpris.get_CanPlay = lambda *_: False
|
||||
self.backend.library.dummy_library = [
|
||||
Track(uri='dummy:/test/uri')]
|
||||
self.mpris.OpenUri('dummy:/test/uri')
|
||||
self.assertEquals(len(self.core.current_playlist.tracks.get()), 0)
|
||||
self.assertEqual(len(self.core.current_playlist.tracks.get()), 0)
|
||||
|
||||
def test_open_uri_ignores_uris_with_unknown_uri_scheme(self):
|
||||
self.assertListEqual(self.core.uri_schemes.get(), ['dummy'])
|
||||
@ -785,56 +813,59 @@ class PlayerInterfaceTest(unittest.TestCase):
|
||||
self.backend.library.dummy_library = [
|
||||
Track(uri='notdummy:/test/uri')]
|
||||
self.mpris.OpenUri('notdummy:/test/uri')
|
||||
self.assertEquals(len(self.core.current_playlist.tracks.get()), 0)
|
||||
self.assertEqual(len(self.core.current_playlist.tracks.get()), 0)
|
||||
|
||||
def test_open_uri_adds_uri_to_current_playlist(self):
|
||||
self.mpris.get_CanPlay = lambda *_: True
|
||||
self.backend.library.dummy_library = [
|
||||
Track(uri='dummy:/test/uri')]
|
||||
self.mpris.OpenUri('dummy:/test/uri')
|
||||
self.assertEquals(
|
||||
self.assertEqual(
|
||||
self.core.current_playlist.tracks.get()[0].uri, 'dummy:/test/uri')
|
||||
|
||||
def test_open_uri_starts_playback_of_new_track_if_stopped(self):
|
||||
self.mpris.get_CanPlay = lambda *_: True
|
||||
self.backend.library.dummy_library = [
|
||||
Track(uri='dummy:/test/uri')]
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.assertEquals(self.core.playback.state.get(), STOPPED)
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.assertEqual(self.core.playback.state.get(), STOPPED)
|
||||
|
||||
self.mpris.OpenUri('dummy:/test/uri')
|
||||
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(
|
||||
self.core.playback.current_track.get().uri, 'dummy:/test/uri')
|
||||
|
||||
def test_open_uri_starts_playback_of_new_track_if_paused(self):
|
||||
self.mpris.get_CanPlay = lambda *_: True
|
||||
self.backend.library.dummy_library = [
|
||||
Track(uri='dummy:/test/uri')]
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.core.playback.pause()
|
||||
self.assertEquals(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEqual(self.core.playback.state.get(), PAUSED)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
|
||||
self.mpris.OpenUri('dummy:/test/uri')
|
||||
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(
|
||||
self.core.playback.current_track.get().uri, 'dummy:/test/uri')
|
||||
|
||||
def test_open_uri_starts_playback_of_new_track_if_playing(self):
|
||||
self.mpris.get_CanPlay = lambda *_: True
|
||||
self.backend.library.dummy_library = [
|
||||
Track(uri='dummy:/test/uri')]
|
||||
self.core.current_playlist.append([Track(uri='a'), Track(uri='b')])
|
||||
self.core.current_playlist.append([
|
||||
Track(uri='dummy:a'), Track(uri='dummy:b')])
|
||||
self.core.playback.play()
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(self.core.playback.current_track.get().uri, 'a')
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(self.core.playback.current_track.get().uri, 'dummy:a')
|
||||
|
||||
self.mpris.OpenUri('dummy:/test/uri')
|
||||
|
||||
self.assertEquals(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEquals(
|
||||
self.assertEqual(self.core.playback.state.get(), PLAYING)
|
||||
self.assertEqual(
|
||||
self.core.playback.current_track.get().uri, 'dummy:/test/uri')
|
||||
|
||||
Loading…
Reference in New Issue
Block a user