diff --git a/mopidy/backends/dummy.py b/mopidy/backends/dummy.py index 3a1d65b7..94bb9b1d 100644 --- a/mopidy/backends/dummy.py +++ b/mopidy/backends/dummy.py @@ -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 diff --git a/tests/backends/events_test.py b/tests/backends/events_test.py index 9c552f39..a25a73c2 100644 --- a/tests/backends/events_test.py +++ b/tests/backends/events_test.py @@ -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() diff --git a/tests/frontends/mpd/protocol/playback_test.py b/tests/frontends/mpd/protocol/playback_test.py index 431c4663..ab254bdf 100644 --- a/tests/frontends/mpd/protocol/playback_test.py +++ b/tests/frontends/mpd/protocol/playback_test.py @@ -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()) diff --git a/tests/frontends/mpd/protocol/regression_test.py b/tests/frontends/mpd/protocol/regression_test.py index a7b7611d..a90e37ab 100644 --- a/tests/frontends/mpd/protocol/regression_test.py +++ b/tests/frontends/mpd/protocol/regression_test.py @@ -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') diff --git a/tests/frontends/mpd/status_test.py b/tests/frontends/mpd/status_test.py index c1b43deb..46f500e7 100644 --- a/tests/frontends/mpd/status_test.py +++ b/tests/frontends/mpd/status_test.py @@ -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) diff --git a/tests/frontends/mpris/player_interface_test.py b/tests/frontends/mpris/player_interface_test.py index 34375098..bd0c1728 100644 --- a/tests/frontends/mpris/player_interface_test.py +++ b/tests/frontends/mpris/player_interface_test.py @@ -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')