From ac60bcdf8e1162f9a72d1ed9aa3b003868be5332 Mon Sep 17 00:00:00 2001 From: Stein Magnus Jodal Date: Tue, 16 Oct 2012 14:43:31 +0200 Subject: [PATCH] Fix all flake8 warnings in tests (#211) --- tests/__init__.py | 2 +- tests/audio_test.py | 14 +-- tests/backends/base/current_playlist.py | 11 ++- tests/backends/base/library.py | 12 ++- tests/backends/base/playback.py | 45 +++++---- tests/backends/base/stored_playlists.py | 2 +- tests/backends/local/current_playlist_test.py | 10 +- tests/backends/local/library_test.py | 4 - tests/backends/local/playback_test.py | 8 +- tests/backends/local/stored_playlists_test.py | 6 +- tests/backends/local/translator_test.py | 57 ++++++----- tests/frontends/mpd/dispatcher_test.py | 8 +- tests/frontends/mpd/exception_test.py | 14 ++- tests/frontends/mpd/protocol/__init__.py | 18 ++-- .../mpd/protocol/command_list_test.py | 4 +- .../frontends/mpd/protocol/connection_test.py | 2 +- .../mpd/protocol/current_playlist_test.py | 16 +-- tests/frontends/mpd/protocol/playback_test.py | 44 ++++----- .../frontends/mpd/protocol/regression_test.py | 5 +- .../mpd/protocol/stored_playlists_test.py | 9 +- tests/frontends/mpd/serializer_test.py | 11 ++- tests/frontends/mpd/status_test.py | 4 +- tests/frontends/mpris/events_test.py | 7 +- .../frontends/mpris/player_interface_test.py | 92 +++++++++--------- tests/models_test.py | 97 ++++++++++--------- tests/scanner_test.py | 9 +- tests/utils/deps_test.py | 6 +- tests/utils/network/connection_test.py | 59 ++++++----- tests/utils/network/lineprotocol_test.py | 4 +- tests/utils/network/server_test.py | 65 +++++++------ tests/utils/network/utils_test.py | 8 +- tests/utils/path_test.py | 21 ++-- tests/utils/settings_test.py | 70 +++++++------ 33 files changed, 396 insertions(+), 348 deletions(-) diff --git a/tests/__init__.py b/tests/__init__.py index 833ff239..5d9ea2b5 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -4,7 +4,7 @@ import sys if sys.version_info < (2, 7): import unittest2 as unittest else: - import unittest + import unittest # noqa from mopidy import settings diff --git a/tests/audio_test.py b/tests/audio_test.py index fcafa75f..852ce36b 100644 --- a/tests/audio_test.py +++ b/tests/audio_test.py @@ -1,13 +1,9 @@ -import sys - from mopidy import audio, settings from mopidy.utils.path import path_to_uri from tests import unittest, path_to_data_dir -@unittest.skipIf(sys.platform == 'win32', - 'Our Windows build server does not support GStreamer yet') class AudioTest(unittest.TestCase): def setUp(self): settings.MIXER = 'fakemixer track_max_volume=65536' @@ -43,11 +39,11 @@ class AudioTest(unittest.TestCase): @unittest.SkipTest def test_deliver_data(self): - pass # TODO + pass # TODO @unittest.SkipTest def test_end_of_data_stream(self): - pass # TODO + pass # TODO def test_set_volume(self): for value in range(0, 101): @@ -56,12 +52,12 @@ class AudioTest(unittest.TestCase): @unittest.SkipTest def test_set_state_encapsulation(self): - pass # TODO + pass # TODO @unittest.SkipTest def test_set_position(self): - pass # TODO + pass # TODO @unittest.SkipTest def test_invalid_output_raises_error(self): - pass # TODO + pass # TODO diff --git a/tests/backends/base/current_playlist.py b/tests/backends/base/current_playlist.py index db4473bb..00ffaea8 100644 --- a/tests/backends/base/current_playlist.py +++ b/tests/backends/base/current_playlist.py @@ -48,7 +48,8 @@ class CurrentPlaylistControllerTest(object): @populate_playlist def test_add_at_position_outside_of_playlist(self): - test = lambda: self.controller.add(self.tracks[0], len(self.tracks)+2) + test = lambda: self.controller.add( + self.tracks[0], len(self.tracks) + 2) self.assertRaises(AssertionError, test) @populate_playlist @@ -180,19 +181,19 @@ class CurrentPlaylistControllerTest(object): @populate_playlist def test_moving_track_outside_of_playlist(self): tracks = len(self.controller.tracks) - test = lambda: self.controller.move(0, 0, tracks+5) + test = lambda: self.controller.move(0, 0, tracks + 5) self.assertRaises(AssertionError, test) @populate_playlist def test_move_group_outside_of_playlist(self): tracks = len(self.controller.tracks) - test = lambda: self.controller.move(0, 2, tracks+5) + test = lambda: self.controller.move(0, 2, tracks + 5) self.assertRaises(AssertionError, test) @populate_playlist def test_move_group_out_of_range(self): tracks = len(self.controller.tracks) - test = lambda: self.controller.move(tracks+2, tracks+3, 0) + test = lambda: self.controller.move(tracks + 2, tracks + 3, 0) self.assertRaises(AssertionError, test) @populate_playlist @@ -253,7 +254,7 @@ class CurrentPlaylistControllerTest(object): @populate_playlist def test_shuffle_superset(self): tracks = len(self.controller.tracks) - test = lambda: self.controller.shuffle(1, tracks+5) + test = lambda: self.controller.shuffle(1, tracks + 5) self.assertRaises(AssertionError, test) @populate_playlist diff --git a/tests/backends/base/library.py b/tests/backends/base/library.py index 99dce78e..85ba54bb 100644 --- a/tests/backends/base/library.py +++ b/tests/backends/base/library.py @@ -1,5 +1,3 @@ -import mock - from pykka.registry import ActorRegistry from mopidy import core @@ -10,12 +8,16 @@ from tests import unittest, path_to_data_dir class LibraryControllerTest(object): artists = [Artist(name='artist1'), Artist(name='artist2'), Artist()] - albums = [Album(name='album1', artists=artists[:1]), + albums = [ + Album(name='album1', artists=artists[:1]), Album(name='album2', artists=artists[1:2]), Album()] - tracks = [Track(name='track1', length=4000, artists=artists[:1], + tracks = [ + Track( + name='track1', length=4000, artists=artists[:1], album=albums[0], uri='file://' + path_to_data_dir('uri1')), - Track(name='track2', length=4000, artists=artists[1:2], + Track( + name='track2', length=4000, artists=artists[1:2], album=albums[1], uri='file://' + path_to_data_dir('uri2')), Track()] diff --git a/tests/backends/base/playback.py b/tests/backends/base/playback.py index 46863f03..5a3b9157 100644 --- a/tests/backends/base/playback.py +++ b/tests/backends/base/playback.py @@ -125,10 +125,10 @@ class PlaybackControllerTest(object): @populate_playlist def test_previous_more(self): - self.playback.play() # At track 0 - self.playback.next() # At track 1 - self.playback.next() # At track 2 - self.playback.previous() # At track 1 + self.playback.play() # At track 0 + self.playback.next() # At track 1 + self.playback.next() # At track 2 + self.playback.previous() # At track 1 self.assertEqual(self.playback.current_track, self.tracks[1]) @populate_playlist @@ -175,8 +175,8 @@ class PlaybackControllerTest(object): self.playback.next() - self.assertEqual(self.playback.current_playlist_position, - old_position+1) + self.assertEqual( + self.playback.current_playlist_position, old_position + 1) self.assertNotEqual(self.playback.current_track.uri, old_uri) @populate_playlist @@ -311,8 +311,8 @@ class PlaybackControllerTest(object): self.playback.on_end_of_track() - self.assertEqual(self.playback.current_playlist_position, - old_position+1) + self.assertEqual( + self.playback.current_playlist_position, old_position + 1) self.assertNotEqual(self.playback.current_track.uri, old_uri) @populate_playlist @@ -406,7 +406,6 @@ class PlaybackControllerTest(object): self.playback.random = True self.assertEqual(self.playback.track_at_next, self.tracks[2]) - @populate_playlist def test_end_of_track_with_consume(self): self.playback.consume = True @@ -448,10 +447,10 @@ class PlaybackControllerTest(object): @populate_playlist def test_previous_track_after_previous(self): - self.playback.play() # At track 0 - self.playback.next() # At track 1 - self.playback.next() # At track 2 - self.playback.previous() # At track 1 + self.playback.play() # At track 0 + self.playback.next() # At track 1 + self.playback.next() # At track 2 + self.playback.previous() # At track 1 self.assertEqual(self.playback.track_at_previous, self.tracks[0]) def test_previous_track_empty_playlist(self): @@ -462,16 +461,16 @@ class PlaybackControllerTest(object): self.playback.consume = True for _ in self.tracks: self.playback.next() - self.assertEqual(self.playback.track_at_previous, - self.playback.current_track) + self.assertEqual( + self.playback.track_at_previous, self.playback.current_track) @populate_playlist def test_previous_track_with_random(self): self.playback.random = True for _ in self.tracks: self.playback.next() - self.assertEqual(self.playback.track_at_previous, - self.playback.current_track) + self.assertEqual( + self.playback.track_at_previous, self.playback.current_track) @populate_playlist def test_initial_current_track(self): @@ -522,7 +521,7 @@ class PlaybackControllerTest(object): self.assert_(wrapper.called) - @unittest.SkipTest # Blocks for 10ms + @unittest.SkipTest # Blocks for 10ms @populate_playlist def test_end_of_track_callback_gets_called(self): self.playback.play() @@ -601,7 +600,7 @@ class PlaybackControllerTest(object): self.playback.pause() self.assertEqual(self.playback.resume(), None) - @unittest.SkipTest # Uses sleep and might not work with LocalBackend + @unittest.SkipTest # Uses sleep and might not work with LocalBackend @populate_playlist def test_resume_continues_from_right_position(self): self.playback.play() @@ -675,13 +674,13 @@ class PlaybackControllerTest(object): def test_seek_beyond_end_of_song(self): # FIXME need to decide return value self.playback.play() - result = self.playback.seek(self.tracks[0].length*100) + result = self.playback.seek(self.tracks[0].length * 100) self.assert_(not result, 'Seek return value was %s' % result) @populate_playlist def test_seek_beyond_end_of_song_jumps_to_next_song(self): self.playback.play() - self.playback.seek(self.tracks[0].length*100) + self.playback.seek(self.tracks[0].length * 100) self.assertEqual(self.playback.current_track, self.tracks[1]) @populate_playlist @@ -743,7 +742,7 @@ class PlaybackControllerTest(object): self.assertEqual(self.playback.time_position, 0) - @unittest.SkipTest # Uses sleep and does might not work with LocalBackend + @unittest.SkipTest # Uses sleep and does might not work with LocalBackend @populate_playlist def test_time_position_when_playing(self): self.playback.play() @@ -752,7 +751,7 @@ class PlaybackControllerTest(object): second = self.playback.time_position self.assertGreater(second, first) - @unittest.SkipTest # Uses sleep + @unittest.SkipTest # Uses sleep @populate_playlist def test_time_position_when_paused(self): self.playback.play() diff --git a/tests/backends/base/stored_playlists.py b/tests/backends/base/stored_playlists.py index 4e65c034..c16be173 100644 --- a/tests/backends/base/stored_playlists.py +++ b/tests/backends/base/stored_playlists.py @@ -19,7 +19,7 @@ class StoredPlaylistsControllerTest(object): self.audio = mock.Mock(spec=audio.Audio) self.backend = self.backend_class.start(audio=self.audio).proxy() self.core = core.Core(backend=self.backend) - self.stored = self.core.stored_playlists + self.stored = self.core.stored_playlists def tearDown(self): if os.path.exists(settings.LOCAL_PLAYLIST_PATH): diff --git a/tests/backends/local/current_playlist_test.py b/tests/backends/local/current_playlist_test.py index a475a6fd..52fa9eb5 100644 --- a/tests/backends/local/current_playlist_test.py +++ b/tests/backends/local/current_playlist_test.py @@ -1,5 +1,3 @@ -import sys - from mopidy import settings from mopidy.backends.local import LocalBackend from mopidy.models import Track @@ -9,14 +7,12 @@ from tests.backends.base.current_playlist import CurrentPlaylistControllerTest from tests.backends.local import generate_song -@unittest.skipIf(sys.platform == 'win32', - 'Our Windows build server does not support GStreamer yet') class LocalCurrentPlaylistControllerTest(CurrentPlaylistControllerTest, - unittest.TestCase): + unittest.TestCase): backend_class = LocalBackend - tracks = [Track(uri=generate_song(i), length=4464) - for i in range(1, 4)] + tracks = [ + Track(uri=generate_song(i), length=4464) for i in range(1, 4)] def setUp(self): settings.BACKENDS = ('mopidy.backends.local.LocalBackend',) diff --git a/tests/backends/local/library_test.py b/tests/backends/local/library_test.py index 046e747a..75cebdbc 100644 --- a/tests/backends/local/library_test.py +++ b/tests/backends/local/library_test.py @@ -1,5 +1,3 @@ -import sys - from mopidy import settings from mopidy.backends.local import LocalBackend @@ -7,8 +5,6 @@ from tests import unittest, path_to_data_dir from tests.backends.base.library import LibraryControllerTest -@unittest.skipIf(sys.platform == 'win32', - 'Our Windows build server does not support GStreamer yet') class LocalLibraryControllerTest(LibraryControllerTest, unittest.TestCase): backend_class = LocalBackend diff --git a/tests/backends/local/playback_test.py b/tests/backends/local/playback_test.py index fe5fee32..fea93ae3 100644 --- a/tests/backends/local/playback_test.py +++ b/tests/backends/local/playback_test.py @@ -1,5 +1,3 @@ -import sys - from mopidy import settings from mopidy.backends.local import LocalBackend from mopidy.core import PlaybackState @@ -11,12 +9,10 @@ from tests.backends.base.playback import PlaybackControllerTest from tests.backends.local import generate_song -@unittest.skipIf(sys.platform == 'win32', - 'Our Windows build server does not support GStreamer yet') class LocalPlaybackControllerTest(PlaybackControllerTest, unittest.TestCase): backend_class = LocalBackend - tracks = [Track(uri=generate_song(i), length=4464) - for i in range(1, 4)] + tracks = [ + Track(uri=generate_song(i), length=4464) for i in range(1, 4)] def setUp(self): settings.BACKENDS = ('mopidy.backends.local.LocalBackend',) diff --git a/tests/backends/local/stored_playlists_test.py b/tests/backends/local/stored_playlists_test.py index 3f3d9c58..437152fe 100644 --- a/tests/backends/local/stored_playlists_test.py +++ b/tests/backends/local/stored_playlists_test.py @@ -1,6 +1,4 @@ import os -import sys - from mopidy import settings from mopidy.backends.local import LocalBackend from mopidy.models import Playlist, Track @@ -12,10 +10,8 @@ from tests.backends.base.stored_playlists import ( from tests.backends.local import generate_song -@unittest.skipIf(sys.platform == 'win32', - 'Our Windows build server does not support GStreamer yet') class LocalStoredPlaylistsControllerTest(StoredPlaylistsControllerTest, - unittest.TestCase): + unittest.TestCase): backend_class = LocalBackend diff --git a/tests/backends/local/translator_test.py b/tests/backends/local/translator_test.py index 08f29c1b..6f754399 100644 --- a/tests/backends/local/translator_test.py +++ b/tests/backends/local/translator_test.py @@ -55,7 +55,7 @@ class M3UToUriTest(unittest.TestCase): def test_file_with_multiple_absolute_files(self): with tempfile.NamedTemporaryFile(delete=False) as tmp: - tmp.write(song1_path+'\n') + tmp.write(song1_path + '\n') tmp.write('# comment \n') tmp.write(song2_path) try: @@ -87,17 +87,21 @@ class M3UToUriTest(unittest.TestCase): class URItoM3UTest(unittest.TestCase): pass + expected_artists = [Artist(name='name')] -expected_albums = [Album(name='albumname', artists=expected_artists, - num_tracks=2)] +expected_albums = [ + Album(name='albumname', artists=expected_artists, num_tracks=2)] expected_tracks = [] + def generate_track(path, ident): uri = path_to_uri(path_to_data_dir(path)) - track = Track(name='trackname', artists=expected_artists, track_no=1, + track = Track( + name='trackname', artists=expected_artists, track_no=1, album=expected_albums[0], length=4000, uri=uri) expected_tracks.append(track) + generate_track('song1.mp3', 6) generate_track('song2.mp3', 7) generate_track('song3.mp3', 8) @@ -108,34 +112,36 @@ generate_track('subdir2/song7.mp3', 5) generate_track('subdir1/subsubdir/song8.mp3', 0) generate_track('subdir1/subsubdir/song9.mp3', 1) + class MPDTagCacheToTracksTest(unittest.TestCase): def test_emtpy_cache(self): - tracks = parse_mpd_tag_cache(path_to_data_dir('empty_tag_cache'), - path_to_data_dir('')) + tracks = parse_mpd_tag_cache( + path_to_data_dir('empty_tag_cache'), path_to_data_dir('')) self.assertEqual(set(), tracks) def test_simple_cache(self): - tracks = parse_mpd_tag_cache(path_to_data_dir('simple_tag_cache'), - path_to_data_dir('')) + tracks = parse_mpd_tag_cache( + path_to_data_dir('simple_tag_cache'), path_to_data_dir('')) uri = path_to_uri(path_to_data_dir('song1.mp3')) - track = Track(name='trackname', artists=expected_artists, track_no=1, + track = Track( + name='trackname', artists=expected_artists, track_no=1, album=expected_albums[0], length=4000, uri=uri) self.assertEqual(set([track]), tracks) def test_advanced_cache(self): - tracks = parse_mpd_tag_cache(path_to_data_dir('advanced_tag_cache'), - path_to_data_dir('')) + tracks = parse_mpd_tag_cache( + path_to_data_dir('advanced_tag_cache'), path_to_data_dir('')) self.assertEqual(set(expected_tracks), tracks) def test_unicode_cache(self): - tracks = parse_mpd_tag_cache(path_to_data_dir('utf8_tag_cache'), - path_to_data_dir('')) + tracks = parse_mpd_tag_cache( + path_to_data_dir('utf8_tag_cache'), path_to_data_dir('')) uri = path_to_uri(path_to_data_dir('song1.mp3')) artists = [Artist(name=u'æøå')] album = Album(name=u'æøå', artists=artists) - track = Track(uri=uri, name=u'æøå', artists=artists, - album=album, length=4000) + track = Track( + uri=uri, name=u'æøå', artists=artists, album=album, length=4000) self.assertEqual(track, list(tracks)[0]) @@ -145,32 +151,35 @@ class MPDTagCacheToTracksTest(unittest.TestCase): pass def test_cache_with_blank_track_info(self): - tracks = parse_mpd_tag_cache(path_to_data_dir('blank_tag_cache'), - path_to_data_dir('')) + tracks = parse_mpd_tag_cache( + path_to_data_dir('blank_tag_cache'), path_to_data_dir('')) uri = path_to_uri(path_to_data_dir('song1.mp3')) self.assertEqual(set([Track(uri=uri, length=4000)]), tracks) def test_musicbrainz_tagcache(self): - tracks = parse_mpd_tag_cache(path_to_data_dir('musicbrainz_tag_cache'), - path_to_data_dir('')) + tracks = parse_mpd_tag_cache( + path_to_data_dir('musicbrainz_tag_cache'), path_to_data_dir('')) artist = list(expected_tracks[0].artists)[0].copy( musicbrainz_id='7364dea6-ca9a-48e3-be01-b44ad0d19897') albumartist = list(expected_tracks[0].artists)[0].copy( name='albumartistname', musicbrainz_id='7364dea6-ca9a-48e3-be01-b44ad0d19897') - album = expected_tracks[0].album.copy(artists=[albumartist], + album = expected_tracks[0].album.copy( + artists=[albumartist], musicbrainz_id='cb5f1603-d314-4c9c-91e5-e295cfb125d2') - track = expected_tracks[0].copy(artists=[artist], album=album, + track = expected_tracks[0].copy( + artists=[artist], album=album, musicbrainz_id='90488461-8c1f-4a4e-826b-4c6dc70801f0') self.assertEqual(track, list(tracks)[0]) def test_albumartist_tag_cache(self): - tracks = parse_mpd_tag_cache(path_to_data_dir('albumartist_tag_cache'), - path_to_data_dir('')) + tracks = parse_mpd_tag_cache( + path_to_data_dir('albumartist_tag_cache'), path_to_data_dir('')) uri = path_to_uri(path_to_data_dir('song1.mp3')) artist = Artist(name='albumartistname') album = expected_albums[0].copy(artists=[artist]) - track = Track(name='trackname', artists=expected_artists, track_no=1, + track = Track( + name='trackname', artists=expected_artists, track_no=1, album=album, length=4000, uri=uri) self.assertEqual(track, list(tracks)[0]) diff --git a/tests/frontends/mpd/dispatcher_test.py b/tests/frontends/mpd/dispatcher_test.py index 0bff04e7..0b5098c1 100644 --- a/tests/frontends/mpd/dispatcher_test.py +++ b/tests/frontends/mpd/dispatcher_test.py @@ -32,14 +32,16 @@ class MpdDispatcherTest(unittest.TestCase): self.dispatcher._find_handler('an_unknown_command with args') self.fail('Should raise exception') except MpdAckError as e: - self.assertEqual(e.get_mpd_ack(), + self.assertEqual( + e.get_mpd_ack(), u'ACK [5@0] {} unknown command "an_unknown_command"') - def test_finding_handler_for_known_command_returns_handler_and_kwargs(self): + def test_find_handler_for_known_command_returns_handler_and_kwargs(self): expected_handler = lambda x: None request_handlers['known_command (?P.+)'] = \ expected_handler - (handler, kwargs) = self.dispatcher._find_handler('known_command an_arg') + (handler, kwargs) = self.dispatcher._find_handler( + 'known_command an_arg') self.assertEqual(handler, expected_handler) self.assertIn('arg1', kwargs) self.assertEqual(kwargs['arg1'], 'an_arg') diff --git a/tests/frontends/mpd/exception_test.py b/tests/frontends/mpd/exception_test.py index 2ea3fe62..8fb0c933 100644 --- a/tests/frontends/mpd/exception_test.py +++ b/tests/frontends/mpd/exception_test.py @@ -1,5 +1,6 @@ -from mopidy.frontends.mpd.exceptions import (MpdAckError, MpdPermissionError, - MpdUnknownCommand, MpdSystemError, MpdNotImplemented) +from mopidy.frontends.mpd.exceptions import ( + MpdAckError, MpdPermissionError, MpdUnknownCommand, MpdSystemError, + MpdNotImplemented) from tests import unittest @@ -34,19 +35,22 @@ class MpdExceptionsTest(unittest.TestCase): try: raise MpdUnknownCommand(command=u'play') except MpdAckError as e: - self.assertEqual(e.get_mpd_ack(), + self.assertEqual( + e.get_mpd_ack(), u'ACK [5@0] {} unknown command "play"') def test_mpd_system_error(self): try: raise MpdSystemError('foo') except MpdSystemError as e: - self.assertEqual(e.get_mpd_ack(), + self.assertEqual( + e.get_mpd_ack(), u'ACK [52@0] {} foo') def test_mpd_permission_error(self): try: raise MpdPermissionError(command='foo') except MpdPermissionError as e: - self.assertEqual(e.get_mpd_ack(), + self.assertEqual( + e.get_mpd_ack(), u'ACK [4@0] {foo} you don\'t have permission for "foo"') diff --git a/tests/frontends/mpd/protocol/__init__.py b/tests/frontends/mpd/protocol/__init__.py index 041b6532..63c253d9 100644 --- a/tests/frontends/mpd/protocol/__init__.py +++ b/tests/frontends/mpd/protocol/__init__.py @@ -45,17 +45,23 @@ class BaseTestCase(unittest.TestCase): self.assertEqual([], self.connection.response) def assertInResponse(self, value): - self.assertIn(value, self.connection.response, u'Did not find %s ' - 'in %s' % (repr(value), repr(self.connection.response))) + self.assertIn( + value, self.connection.response, + u'Did not find %s in %s' % ( + repr(value), repr(self.connection.response))) def assertOnceInResponse(self, value): matched = len([r for r in self.connection.response if r == value]) - self.assertEqual(1, matched, 'Expected to find %s once in %s' % - (repr(value), repr(self.connection.response))) + self.assertEqual( + 1, matched, + u'Expected to find %s once in %s' % ( + repr(value), repr(self.connection.response))) def assertNotInResponse(self, value): - self.assertNotIn(value, self.connection.response, u'Found %s in %s' % - (repr(value), repr(self.connection.response))) + self.assertNotIn( + value, self.connection.response, + u'Found %s in %s' % ( + repr(value), repr(self.connection.response))) def assertEqualResponse(self, value): self.assertEqual(1, len(self.connection.response)) diff --git a/tests/frontends/mpd/protocol/command_list_test.py b/tests/frontends/mpd/protocol/command_list_test.py index 65b051d3..64ef8688 100644 --- a/tests/frontends/mpd/protocol/command_list_test.py +++ b/tests/frontends/mpd/protocol/command_list_test.py @@ -28,8 +28,8 @@ class CommandListsTest(protocol.BaseTestCase): def test_command_list_with_error_returns_ack_with_correct_index(self): self.sendRequest(u'command_list_begin') - self.sendRequest(u'play') # Known command - self.sendRequest(u'paly') # Unknown command + self.sendRequest(u'play') # Known command + self.sendRequest(u'paly') # Unknown command self.sendRequest(u'command_list_end') self.assertEqualResponse(u'ACK [5@1] {} unknown command "paly"') diff --git a/tests/frontends/mpd/protocol/connection_test.py b/tests/frontends/mpd/protocol/connection_test.py index cd08313f..9b8972d3 100644 --- a/tests/frontends/mpd/protocol/connection_test.py +++ b/tests/frontends/mpd/protocol/connection_test.py @@ -8,7 +8,7 @@ from tests.frontends.mpd import protocol class ConnectionHandlerTest(protocol.BaseTestCase): def test_close_closes_the_client_connection(self): with patch.object(self.session, 'close') as close_mock: - response = self.sendRequest(u'close') + self.sendRequest(u'close') close_mock.assertEqualResponsecalled_once_with() self.assertEqualResponse(u'OK') diff --git a/tests/frontends/mpd/protocol/current_playlist_test.py b/tests/frontends/mpd/protocol/current_playlist_test.py index 63c4a42b..a64b08ea 100644 --- a/tests/frontends/mpd/protocol/current_playlist_test.py +++ b/tests/frontends/mpd/protocol/current_playlist_test.py @@ -38,8 +38,8 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.sendRequest(u'addid "dummy://foo"') self.assertEqual(len(self.core.current_playlist.tracks.get()), 6) self.assertEqual(self.core.current_playlist.tracks.get()[5], needle) - self.assertInResponse(u'Id: %d' % - self.core.current_playlist.cp_tracks.get()[5][0]) + self.assertInResponse( + u'Id: %d' % self.core.current_playlist.cp_tracks.get()[5][0]) self.assertInResponse(u'OK') def test_addid_with_empty_uri_acks(self): @@ -57,8 +57,8 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.sendRequest(u'addid "dummy://foo" "3"') self.assertEqual(len(self.core.current_playlist.tracks.get()), 6) self.assertEqual(self.core.current_playlist.tracks.get()[3], needle) - self.assertInResponse(u'Id: %d' % - self.core.current_playlist.cp_tracks.get()[3][0]) + self.assertInResponse( + u'Id: %d' % self.core.current_playlist.cp_tracks.get()[3][0]) self.assertInResponse(u'OK') def test_addid_with_songpos_out_of_bounds_should_ack(self): @@ -91,8 +91,8 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): [Track(), Track(), Track(), Track(), Track()]) self.assertEqual(len(self.core.current_playlist.tracks.get()), 5) - self.sendRequest(u'delete "%d"' % - self.core.current_playlist.cp_tracks.get()[2][0]) + self.sendRequest( + u'delete "%d"' % self.core.current_playlist.cp_tracks.get()[2][0]) self.assertEqual(len(self.core.current_playlist.tracks.get()), 4) self.assertInResponse(u'OK') @@ -233,7 +233,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.core.current_playlist.append([ Track(uri='file:///exists')]) - self.sendRequest( u'playlistfind filename "file:///exists"') + self.sendRequest(u'playlistfind filename "file:///exists"') self.assertInResponse(u'file: file:///exists') self.assertInResponse(u'Id: 0') self.assertInResponse(u'Pos: 0') @@ -357,7 +357,7 @@ class CurrentPlaylistHandlerTest(protocol.BaseTestCase): self.assertInResponse(u'OK') def test_playlistsearch(self): - self.sendRequest( u'playlistsearch "any" "needle"') + self.sendRequest(u'playlistsearch "any" "needle"') self.assertEqualResponse(u'ACK [0@0] {} Not implemented') def test_playlistsearch_without_quotes(self): diff --git a/tests/frontends/mpd/protocol/playback_test.py b/tests/frontends/mpd/protocol/playback_test.py index 2380c7bc..431c4663 100644 --- a/tests/frontends/mpd/protocol/playback_test.py +++ b/tests/frontends/mpd/protocol/playback_test.py @@ -259,29 +259,29 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): def test_play_minus_is_ignored_if_playing(self): self.core.current_playlist.append([Track(length=40000)]) self.core.playback.seek(30000) - self.assertGreaterEqual(self.core.playback.time_position.get(), - 30000) + self.assertGreaterEqual( + self.core.playback.time_position.get(), 30000) self.assertEquals(PLAYING, self.core.playback.state.get()) self.sendRequest(u'play "-1"') self.assertEqual(PLAYING, self.core.playback.state.get()) - self.assertGreaterEqual(self.core.playback.time_position.get(), - 30000) + self.assertGreaterEqual( + self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_play_minus_one_resumes_if_paused(self): self.core.current_playlist.append([Track(length=40000)]) self.core.playback.seek(30000) - self.assertGreaterEqual(self.core.playback.time_position.get(), - 30000) + self.assertGreaterEqual( + self.core.playback.time_position.get(), 30000) self.assertEquals(PLAYING, self.core.playback.state.get()) self.core.playback.pause() self.assertEquals(PAUSED, self.core.playback.state.get()) self.sendRequest(u'play "-1"') self.assertEqual(PLAYING, self.core.playback.state.get()) - self.assertGreaterEqual(self.core.playback.time_position.get(), - 30000) + self.assertGreaterEqual( + self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_playid(self): @@ -298,7 +298,7 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): self.assertEqual(PLAYING, self.core.playback.state.get()) self.assertInResponse(u'OK') - def test_playid_minus_one_plays_first_in_playlist_if_no_current_track(self): + 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')]) @@ -307,7 +307,7 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): self.assertEqual('a', self.core.playback.current_track.get().uri) self.assertInResponse(u'OK') - def test_playid_minus_one_plays_current_track_if_current_track_is_set(self): + 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.assertEqual(self.core.playback.current_track.get(), None) self.core.playback.play() @@ -331,29 +331,29 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): def test_playid_minus_is_ignored_if_playing(self): self.core.current_playlist.append([Track(length=40000)]) self.core.playback.seek(30000) - self.assertGreaterEqual(self.core.playback.time_position.get(), - 30000) + self.assertGreaterEqual( + self.core.playback.time_position.get(), 30000) self.assertEquals(PLAYING, self.core.playback.state.get()) self.sendRequest(u'playid "-1"') self.assertEqual(PLAYING, self.core.playback.state.get()) - self.assertGreaterEqual(self.core.playback.time_position.get(), - 30000) + self.assertGreaterEqual( + self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_playid_minus_one_resumes_if_paused(self): self.core.current_playlist.append([Track(length=40000)]) self.core.playback.seek(30000) - self.assertGreaterEqual(self.core.playback.time_position.get(), - 30000) + self.assertGreaterEqual( + self.core.playback.time_position.get(), 30000) self.assertEquals(PLAYING, self.core.playback.state.get()) self.core.playback.pause() self.assertEquals(PAUSED, self.core.playback.state.get()) self.sendRequest(u'playid "-1"') self.assertEqual(PLAYING, self.core.playback.state.get()) - self.assertGreaterEqual(self.core.playback.time_position.get(), - 30000) + self.assertGreaterEqual( + self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_playid_which_does_not_exist(self): @@ -388,15 +388,15 @@ class PlaybackControlHandlerTest(protocol.BaseTestCase): self.sendRequest(u'seek 0') self.sendRequest(u'seek 0 30') - self.assertGreaterEqual(self.core.playback.time_position.get(), - 30000) + self.assertGreaterEqual( + self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_seekid(self): self.core.current_playlist.append([Track(length=40000)]) self.sendRequest(u'seekid "0" "30"') - self.assertGreaterEqual(self.core.playback.time_position.get(), - 30000) + self.assertGreaterEqual( + self.core.playback.time_position.get(), 30000) self.assertInResponse(u'OK') def test_seekid_with_cpid(self): diff --git a/tests/frontends/mpd/protocol/regression_test.py b/tests/frontends/mpd/protocol/regression_test.py index 90bcaf60..a7b7611d 100644 --- a/tests/frontends/mpd/protocol/regression_test.py +++ b/tests/frontends/mpd/protocol/regression_test.py @@ -19,7 +19,7 @@ class IssueGH17RegressionTest(protocol.BaseTestCase): self.core.current_playlist.append([ Track(uri='a'), Track(uri='b'), None, Track(uri='d'), Track(uri='e'), Track(uri='f')]) - random.seed(1) # Playlist order: abcfde + random.seed(1) # Playlist order: abcfde self.sendRequest(u'play') self.assertEquals('a', self.core.playback.current_track.get().uri) @@ -158,7 +158,8 @@ class IssueGH137RegressionTest(protocol.BaseTestCase): """ def test(self): - self.sendRequest(u'list Date Artist "Anita Ward" ' + self.sendRequest( + u'list Date Artist "Anita Ward" ' u'Album "This Is Remixed Hits - Mashups & Rare 12" Mixes"') self.assertInResponse('ACK [2@0] {list} Invalid unquoted character') diff --git a/tests/frontends/mpd/protocol/stored_playlists_test.py b/tests/frontends/mpd/protocol/stored_playlists_test.py index 0bf9756f..8cfcb338 100644 --- a/tests/frontends/mpd/protocol/stored_playlists_test.py +++ b/tests/frontends/mpd/protocol/stored_playlists_test.py @@ -35,8 +35,8 @@ class StoredPlaylistsHandlerTest(protocol.BaseTestCase): def test_listplaylists(self): last_modified = datetime.datetime(2001, 3, 17, 13, 41, 17, 12345) - self.core.stored_playlists.playlists = [Playlist(name='a', - last_modified=last_modified)] + self.core.stored_playlists.playlists = [ + Playlist(name='a', last_modified=last_modified)] self.sendRequest(u'listplaylists') self.assertInResponse(u'playlist: a') @@ -47,8 +47,9 @@ class StoredPlaylistsHandlerTest(protocol.BaseTestCase): def test_load_known_playlist_appends_to_current_playlist(self): self.core.current_playlist.append([Track(uri='a'), Track(uri='b')]) self.assertEqual(len(self.core.current_playlist.tracks.get()), 2) - self.core.stored_playlists.playlists = [Playlist(name='A-list', - tracks=[Track(uri='c'), Track(uri='d'), Track(uri='e')])] + self.core.stored_playlists.playlists = [ + Playlist(name='A-list', tracks=[ + Track(uri='c'), Track(uri='d'), Track(uri='e')])] self.sendRequest(u'load "A-list"') tracks = self.core.current_playlist.tracks.get() diff --git a/tests/frontends/mpd/serializer_test.py b/tests/frontends/mpd/serializer_test.py index e6cd80e2..2d2a9f87 100644 --- a/tests/frontends/mpd/serializer_test.py +++ b/tests/frontends/mpd/serializer_test.py @@ -49,7 +49,8 @@ class TrackMpdFormatTest(unittest.TestCase): self.assertNotIn(('Id', 1), result) def test_track_to_mpd_format_with_position_and_cpid(self): - result = translator.track_to_mpd_format(CpTrack(2, Track()), position=1) + result = translator.track_to_mpd_format( + CpTrack(2, Track()), position=1) self.assertIn(('Pos', 1), result) self.assertIn(('Id', 2), result) @@ -79,7 +80,7 @@ class TrackMpdFormatTest(unittest.TestCase): result = translator.track_to_mpd_format(track) self.assertIn(('MUSICBRAINZ_ALBUMID', 'foo'), result) - def test_track_to_mpd_format_musicbrainz_albumid(self): + def test_track_to_mpd_format_musicbrainz_albumartistid(self): artist = list(self.track.artists)[0].copy(musicbrainz_id='foo') album = self.track.album.copy(artists=[artist]) track = self.track.copy(album=album) @@ -131,7 +132,7 @@ class TracksToTagCacheFormatTest(unittest.TestCase): folder = settings.LOCAL_MUSIC_PATH result = dict(translator.track_to_mpd_format(track)) result['file'] = uri_to_path(result['file']) - result['file'] = result['file'][len(folder)+1:] + result['file'] = result['file'][len(folder) + 1:] result['key'] = os.path.basename(result['file']) result['mtime'] = mtime('') return translator.order_mpd_track_info(result.items()) @@ -147,7 +148,7 @@ class TracksToTagCacheFormatTest(unittest.TestCase): self.assertEqual(('songList begin',), result[0]) for i, row in enumerate(result): if row == ('songList end',): - return result[1:i], result[i+1:] + return result[1:i], result[i + 1:] self.fail("Couldn't find songList end in result") def consume_directory(self, result): @@ -157,7 +158,7 @@ class TracksToTagCacheFormatTest(unittest.TestCase): directory = result[2][1] for i, row in enumerate(result): if row == ('end', directory): - return result[3:i], result[i+1:] + return result[3:i], result[i + 1:] self.fail("Couldn't find end %s in result" % directory) def test_empty_tag_cache_has_header(self): diff --git a/tests/frontends/mpd/status_test.py b/tests/frontends/mpd/status_test.py index 6322ec36..61fd0854 100644 --- a/tests/frontends/mpd/status_test.py +++ b/tests/frontends/mpd/status_test.py @@ -1,6 +1,6 @@ from pykka.registry import ActorRegistry -from mopidy import audio, core +from mopidy import core from mopidy.backends import dummy from mopidy.core import PlaybackState from mopidy.frontends.mpd import dispatcher @@ -97,7 +97,7 @@ class StatusHandlerTest(unittest.TestCase): def test_status_method_contains_playlist(self): result = dict(status.status(self.context)) self.assertIn('playlist', result) - self.assertIn(int(result['playlist']), xrange(0, 2**31 - 1)) + self.assertIn(int(result['playlist']), xrange(0, 2 ** 31 - 1)) def test_status_method_contains_playlistlength(self): result = dict(status.status(self.context)) diff --git a/tests/frontends/mpris/events_test.py b/tests/frontends/mpris/events_test.py index f466e207..241b9365 100644 --- a/tests/frontends/mpris/events_test.py +++ b/tests/frontends/mpris/events_test.py @@ -16,7 +16,8 @@ from tests import unittest @unittest.skipUnless(sys.platform.startswith('linux'), 'requires Linux') class BackendEventsTest(unittest.TestCase): def setUp(self): - self.mpris_frontend = MprisFrontend(core=None) # As a plain class, not an actor + # As a plain class, not an actor: + self.mpris_frontend = MprisFrontend(core=None) self.mpris_object = mock.Mock(spec=objects.MprisObject) self.mpris_frontend.mpris_object = self.mpris_object @@ -38,7 +39,7 @@ class BackendEventsTest(unittest.TestCase): self.mpris_object.PropertiesChanged.assert_called_with( objects.PLAYER_IFACE, {'PlaybackStatus': 'Playing'}, []) - def test_track_playback_started_event_changes_playback_status_and_metadata(self): + def test_track_playback_started_changes_playback_status_and_metadata(self): self.mpris_object.Get.return_value = '...' self.mpris_frontend.track_playback_started(Track()) self.assertListEqual(self.mpris_object.Get.call_args_list, [ @@ -49,7 +50,7 @@ class BackendEventsTest(unittest.TestCase): objects.PLAYER_IFACE, {'Metadata': '...', 'PlaybackStatus': '...'}, []) - def test_track_playback_ended_event_changes_playback_status_and_metadata(self): + def test_track_playback_ended_changes_playback_status_and_metadata(self): self.mpris_object.Get.return_value = '...' self.mpris_frontend.track_playback_ended(Track(), 0) self.assertListEqual(self.mpris_object.Get.call_args_list, [ diff --git a/tests/frontends/mpris/player_interface_test.py b/tests/frontends/mpris/player_interface_test.py index 403d05c7..6088a94b 100644 --- a/tests/frontends/mpris/player_interface_test.py +++ b/tests/frontends/mpris/player_interface_test.py @@ -59,7 +59,7 @@ class PlayerInterfaceTest(unittest.TestCase): result = self.mpris.Get(objects.PLAYER_IFACE, 'LoopStatus') self.assertEqual('Track', result) - def test_get_loop_status_is_playlist_when_looping_the_current_playlist(self): + def test_get_loop_status_is_playlist_when_looping_current_playlist(self): self.core.playback.repeat = True self.core.playback.single = False result = self.mpris.Get(objects.PLAYER_IFACE, 'LoopStatus') @@ -126,19 +126,19 @@ class PlayerInterfaceTest(unittest.TestCase): def test_set_shuffle_is_ignored_if_can_control_is_false(self): self.mpris.get_CanControl = lambda *_: False self.core.playback.random = False - result = self.mpris.Set(objects.PLAYER_IFACE, 'Shuffle', True) + self.mpris.Set(objects.PLAYER_IFACE, 'Shuffle', True) self.assertFalse(self.core.playback.random.get()) def test_set_shuffle_to_true_activates_random_mode(self): self.core.playback.random = False self.assertFalse(self.core.playback.random.get()) - result = self.mpris.Set(objects.PLAYER_IFACE, 'Shuffle', True) + self.mpris.Set(objects.PLAYER_IFACE, 'Shuffle', True) self.assertTrue(self.core.playback.random.get()) def test_set_shuffle_to_false_deactivates_random_mode(self): self.core.playback.random = True self.assertTrue(self.core.playback.random.get()) - result = self.mpris.Set(objects.PLAYER_IFACE, 'Shuffle', False) + self.mpris.Set(objects.PLAYER_IFACE, 'Shuffle', False) self.assertFalse(self.core.playback.random.get()) def test_get_metadata_has_trackid_even_when_no_current_track(self): @@ -152,8 +152,8 @@ class PlayerInterfaceTest(unittest.TestCase): (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(result['mpris:trackid'], - '/com/mopidy/track/%d' % cpid) + self.assertEquals( + 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)]) @@ -233,7 +233,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.Set(objects.PLAYER_IFACE, 'Volume', 1.0) self.assertEquals(self.core.playback.volume.get(), 100) - def test_set_volume_to_anything_above_one_should_set_mixer_volume_to_100(self): + 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) @@ -246,12 +246,14 @@ class PlayerInterfaceTest(unittest.TestCase): self.core.current_playlist.append([Track(uri='a', length=40000)]) self.core.playback.play() self.core.playback.seek(10000) - result_in_microseconds = self.mpris.Get(objects.PLAYER_IFACE, 'Position') + result_in_microseconds = self.mpris.Get( + objects.PLAYER_IFACE, 'Position') result_in_milliseconds = result_in_microseconds // 1000 self.assertGreaterEqual(result_in_milliseconds, 10000) def test_get_position_when_no_current_track_should_be_zero(self): - result_in_microseconds = self.mpris.Get(objects.PLAYER_IFACE, 'Position') + result_in_microseconds = self.mpris.Get( + objects.PLAYER_IFACE, 'Position') result_in_milliseconds = result_in_microseconds // 1000 self.assertEquals(result_in_milliseconds, 0) @@ -285,7 +287,7 @@ class PlayerInterfaceTest(unittest.TestCase): result = self.mpris.Get(objects.PLAYER_IFACE, 'CanGoNext') self.assertFalse(result) - def test_can_go_previous_is_true_if_can_control_and_other_previous_track(self): + 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.playback.play() @@ -360,7 +362,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.Next() self.assertEquals(self.core.playback.current_track.get().uri, 'a') - def test_next_when_playing_should_skip_to_next_track_and_keep_playing(self): + 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.playback.play() self.assertEquals(self.core.playback.current_track.get().uri, 'a') @@ -388,7 +390,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.assertEquals(self.core.playback.current_track.get().uri, 'b') self.assertEquals(self.core.playback.state.get(), PAUSED) - def test_next_when_stopped_should_skip_to_next_track_and_stay_stopped(self): + 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.playback.play() self.core.playback.stop() @@ -407,7 +409,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.Previous() self.assertEquals(self.core.playback.current_track.get().uri, 'b') - def test_previous_when_playing_should_skip_to_prev_track_and_keep_playing(self): + 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.playback.play() self.core.playback.next() @@ -425,7 +427,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.Previous() self.assertEquals(self.core.playback.state.get(), STOPPED) - def test_previous_when_paused_should_skip_to_previous_track_and_stay_paused(self): + 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.playback.play() self.core.playback.next() @@ -436,7 +438,7 @@ class PlayerInterfaceTest(unittest.TestCase): self.assertEquals(self.core.playback.current_track.get().uri, 'a') self.assertEquals(self.core.playback.state.get(), PAUSED) - def test_previous_when_stopped_should_skip_to_previous_track_and_stay_stopped(self): + 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.playback.play() self.core.playback.next() @@ -638,8 +640,9 @@ class PlayerInterfaceTest(unittest.TestCase): self.assertLess(after_seek, before_seek) self.assertGreaterEqual(after_seek, 0) - def test_seek_skips_to_next_track_if_new_position_larger_than_track_length(self): - self.core.current_playlist.append([Track(uri='a', length=40000), + 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')]) self.core.playback.play() self.core.playback.seek(20000) @@ -671,14 +674,14 @@ class PlayerInterfaceTest(unittest.TestCase): track_id = 'a' - position_to_set_in_milliseconds = 20000 - position_to_set_in_microseconds = position_to_set_in_milliseconds * 1000 + position_to_set_in_millisec = 20000 + position_to_set_in_microsec = position_to_set_in_millisec * 1000 - self.mpris.SetPosition(track_id, position_to_set_in_microseconds) + self.mpris.SetPosition(track_id, position_to_set_in_microsec) after_set_position = self.core.playback.time_position.get() self.assertLessEqual(before_set_position, after_set_position) - self.assertLess(after_set_position, position_to_set_in_milliseconds) + 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)]) @@ -690,15 +693,16 @@ class PlayerInterfaceTest(unittest.TestCase): track_id = '/com/mopidy/track/0' - position_to_set_in_milliseconds = 20000 - position_to_set_in_microseconds = position_to_set_in_milliseconds * 1000 + position_to_set_in_millisec = 20000 + position_to_set_in_microsec = position_to_set_in_millisec * 1000 - self.mpris.SetPosition(track_id, position_to_set_in_microseconds) + self.mpris.SetPosition(track_id, position_to_set_in_microsec) self.assertEquals(self.core.playback.state.get(), PLAYING) after_set_position = self.core.playback.time_position.get() - self.assertGreaterEqual(after_set_position, position_to_set_in_milliseconds) + 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)]) @@ -713,17 +717,17 @@ class PlayerInterfaceTest(unittest.TestCase): track_id = '/com/mopidy/track/0' - position_to_set_in_milliseconds = -1000 - position_to_set_in_microseconds = position_to_set_in_milliseconds * 1000 + position_to_set_in_millisec = -1000 + position_to_set_in_microsec = position_to_set_in_millisec * 1000 - self.mpris.SetPosition(track_id, position_to_set_in_microseconds) + self.mpris.SetPosition(track_id, position_to_set_in_microsec) 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') - def test_set_position_does_nothing_if_position_is_larger_than_track_length(self): + 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.playback.play() self.core.playback.seek(20000) @@ -736,17 +740,17 @@ class PlayerInterfaceTest(unittest.TestCase): track_id = 'a' - position_to_set_in_milliseconds = 50000 - position_to_set_in_microseconds = position_to_set_in_milliseconds * 1000 + position_to_set_in_millisec = 50000 + position_to_set_in_microsec = position_to_set_in_millisec * 1000 - self.mpris.SetPosition(track_id, position_to_set_in_microseconds) + self.mpris.SetPosition(track_id, position_to_set_in_microsec) 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') - def test_set_position_does_nothing_if_track_id_does_not_match_current_track(self): + 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.playback.play() self.core.playback.seek(20000) @@ -759,10 +763,10 @@ class PlayerInterfaceTest(unittest.TestCase): track_id = 'b' - position_to_set_in_milliseconds = 0 - position_to_set_in_microseconds = position_to_set_in_milliseconds * 1000 + position_to_set_in_millisec = 0 + position_to_set_in_microsec = position_to_set_in_millisec * 1000 - self.mpris.SetPosition(track_id, position_to_set_in_microseconds) + self.mpris.SetPosition(track_id, position_to_set_in_microsec) after_set_position = self.core.playback.time_position.get() self.assertGreaterEqual(after_set_position, before_set_position) @@ -789,8 +793,8 @@ class PlayerInterfaceTest(unittest.TestCase): self.backend.library.dummy_library = [ Track(uri='dummy:/test/uri')] self.mpris.OpenUri('dummy:/test/uri') - self.assertEquals(self.core.current_playlist.tracks.get()[0].uri, - 'dummy:/test/uri') + self.assertEquals( + 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 @@ -802,8 +806,8 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.OpenUri('dummy:/test/uri') self.assertEquals(self.core.playback.state.get(), PLAYING) - self.assertEquals(self.core.playback.current_track.get().uri, - 'dummy:/test/uri') + self.assertEquals( + 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 @@ -818,8 +822,8 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.OpenUri('dummy:/test/uri') self.assertEquals(self.core.playback.state.get(), PLAYING) - self.assertEquals(self.core.playback.current_track.get().uri, - 'dummy:/test/uri') + self.assertEquals( + 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 @@ -833,5 +837,5 @@ class PlayerInterfaceTest(unittest.TestCase): self.mpris.OpenUri('dummy:/test/uri') self.assertEquals(self.core.playback.state.get(), PLAYING) - self.assertEquals(self.core.playback.current_track.get().uri, - 'dummy:/test/uri') + self.assertEquals( + self.core.playback.current_track.get().uri, 'dummy:/test/uri') diff --git a/tests/models_test.py b/tests/models_test.py index 779d1a4b..a3c9cc96 100644 --- a/tests/models_test.py +++ b/tests/models_test.py @@ -67,8 +67,8 @@ class ArtistTest(unittest.TestCase): mb_id = u'mb-id' artist = Artist(musicbrainz_id=mb_id) self.assertEqual(artist.musicbrainz_id, mb_id) - self.assertRaises(AttributeError, setattr, artist, - 'musicbrainz_id', None) + self.assertRaises( + AttributeError, setattr, artist, 'musicbrainz_id', None) def test_invalid_kwarg(self): test = lambda: Artist(foo='baz') @@ -168,8 +168,8 @@ class AlbumTest(unittest.TestCase): mb_id = u'mb-id' album = Album(musicbrainz_id=mb_id) self.assertEqual(album.musicbrainz_id, mb_id) - self.assertRaises(AttributeError, setattr, album, - 'musicbrainz_id', None) + self.assertRaises( + AttributeError, setattr, album, 'musicbrainz_id', None) def test_invalid_kwarg(self): test = lambda: Album(foo='baz') @@ -237,9 +237,11 @@ class AlbumTest(unittest.TestCase): def test_eq(self): artists = [Artist()] - album1 = Album(name=u'name', uri=u'uri', artists=artists, num_tracks=2, + album1 = Album( + name=u'name', uri=u'uri', artists=artists, num_tracks=2, musicbrainz_id='id') - album2 = Album(name=u'name', uri=u'uri', artists=artists, num_tracks=2, + album2 = Album( + name=u'name', uri=u'uri', artists=artists, num_tracks=2, musicbrainz_id='id') self.assertEqual(album1, album2) self.assertEqual(hash(album1), hash(album2)) @@ -281,12 +283,12 @@ class AlbumTest(unittest.TestCase): self.assertNotEqual(hash(album1), hash(album2)) def test_ne(self): - album1 = Album(name=u'name1', uri=u'uri1', - artists=[Artist(name=u'name1')], num_tracks=1, - musicbrainz_id='id1') - album2 = Album(name=u'name2', uri=u'uri2', - artists=[Artist(name=u'name2')], num_tracks=2, - musicbrainz_id='id2') + album1 = Album( + name=u'name1', uri=u'uri1', artists=[Artist(name=u'name1')], + num_tracks=1, musicbrainz_id='id1') + album2 = Album( + name=u'name2', uri=u'uri2', artists=[Artist(name=u'name2')], + num_tracks=2, musicbrainz_id='id2') self.assertNotEqual(album1, album2) self.assertNotEqual(hash(album1), hash(album2)) @@ -359,8 +361,8 @@ class TrackTest(unittest.TestCase): mb_id = u'mb-id' track = Track(musicbrainz_id=mb_id) self.assertEqual(track.musicbrainz_id, mb_id) - self.assertRaises(AttributeError, setattr, track, - 'musicbrainz_id', None) + self.assertRaises( + AttributeError, setattr, track, 'musicbrainz_id', None) def test_invalid_kwarg(self): test = lambda: Track(foo='baz') @@ -462,12 +464,12 @@ class TrackTest(unittest.TestCase): date = '1977-01-01' artists = [Artist()] album = Album() - track1 = Track(uri=u'uri', name=u'name', artists=artists, album=album, - track_no=1, date=date, length=100, bitrate=100, - musicbrainz_id='id') - track2 = Track(uri=u'uri', name=u'name', artists=artists, album=album, - track_no=1, date=date, length=100, bitrate=100, - musicbrainz_id='id') + track1 = Track( + uri=u'uri', name=u'name', artists=artists, album=album, track_no=1, + date=date, length=100, bitrate=100, musicbrainz_id='id') + track2 = Track( + uri=u'uri', name=u'name', artists=artists, album=album, track_no=1, + date=date, length=100, bitrate=100, musicbrainz_id='id') self.assertEqual(track1, track2) self.assertEqual(hash(track1), hash(track2)) @@ -532,14 +534,14 @@ class TrackTest(unittest.TestCase): self.assertNotEqual(hash(track1), hash(track2)) def test_ne(self): - track1 = Track(uri=u'uri1', name=u'name1', - artists=[Artist(name=u'name1')], album=Album(name=u'name1'), - track_no=1, date='1977-01-01', length=100, bitrate=100, - musicbrainz_id='id1') - track2 = Track(uri=u'uri2', name=u'name2', - artists=[Artist(name=u'name2')], album=Album(name=u'name2'), - track_no=2, date='1977-01-02', length=200, bitrate=200, - musicbrainz_id='id2') + track1 = Track( + uri=u'uri1', name=u'name1', artists=[Artist(name=u'name1')], + album=Album(name=u'name1'), track_no=1, date='1977-01-01', + length=100, bitrate=100, musicbrainz_id='id1') + track2 = Track( + uri=u'uri2', name=u'name2', artists=[Artist(name=u'name2')], + album=Album(name=u'name2'), track_no=2, date='1977-01-02', + length=200, bitrate=200, musicbrainz_id='id2') self.assertNotEqual(track1, track2) self.assertNotEqual(hash(track1), hash(track2)) @@ -572,13 +574,14 @@ class PlaylistTest(unittest.TestCase): last_modified = datetime.datetime.now() playlist = Playlist(last_modified=last_modified) self.assertEqual(playlist.last_modified, last_modified) - self.assertRaises(AttributeError, setattr, playlist, 'last_modified', - None) + self.assertRaises( + AttributeError, setattr, playlist, 'last_modified', None) def test_with_new_uri(self): tracks = [Track()] last_modified = datetime.datetime.now() - playlist = Playlist(uri=u'an uri', name=u'a name', tracks=tracks, + playlist = Playlist( + uri=u'an uri', name=u'a name', tracks=tracks, last_modified=last_modified) new_playlist = playlist.copy(uri=u'another uri') self.assertEqual(new_playlist.uri, u'another uri') @@ -589,7 +592,8 @@ class PlaylistTest(unittest.TestCase): def test_with_new_name(self): tracks = [Track()] last_modified = datetime.datetime.now() - playlist = Playlist(uri=u'an uri', name=u'a name', tracks=tracks, + playlist = Playlist( + uri=u'an uri', name=u'a name', tracks=tracks, last_modified=last_modified) new_playlist = playlist.copy(name=u'another name') self.assertEqual(new_playlist.uri, u'an uri') @@ -600,7 +604,8 @@ class PlaylistTest(unittest.TestCase): def test_with_new_tracks(self): tracks = [Track()] last_modified = datetime.datetime.now() - playlist = Playlist(uri=u'an uri', name=u'a name', tracks=tracks, + playlist = Playlist( + uri=u'an uri', name=u'a name', tracks=tracks, last_modified=last_modified) new_tracks = [Track(), Track()] new_playlist = playlist.copy(tracks=new_tracks) @@ -613,7 +618,8 @@ class PlaylistTest(unittest.TestCase): tracks = [Track()] last_modified = datetime.datetime.now() new_last_modified = last_modified + datetime.timedelta(1) - playlist = Playlist(uri=u'an uri', name=u'a name', tracks=tracks, + playlist = Playlist( + uri=u'an uri', name=u'a name', tracks=tracks, last_modified=last_modified) new_playlist = playlist.copy(last_modified=new_last_modified) self.assertEqual(new_playlist.uri, u'an uri') @@ -666,7 +672,7 @@ class PlaylistTest(unittest.TestCase): self.assertEqual(playlist1, playlist2) self.assertEqual(hash(playlist1), hash(playlist2)) - def test_eq_uri(self): + def test_eq_last_modified(self): playlist1 = Playlist(last_modified=1) playlist2 = Playlist(last_modified=1) self.assertEqual(playlist1, playlist2) @@ -674,10 +680,10 @@ class PlaylistTest(unittest.TestCase): def test_eq(self): tracks = [Track()] - playlist1 = Playlist(uri=u'uri', name=u'name', tracks=tracks, - last_modified=1) - playlist2 = Playlist(uri=u'uri', name=u'name', tracks=tracks, - last_modified=1) + playlist1 = Playlist( + uri=u'uri', name=u'name', tracks=tracks, last_modified=1) + playlist2 = Playlist( + uri=u'uri', name=u'name', tracks=tracks, last_modified=1) self.assertEqual(playlist1, playlist2) self.assertEqual(hash(playlist1), hash(playlist2)) @@ -705,17 +711,18 @@ class PlaylistTest(unittest.TestCase): self.assertNotEqual(playlist1, playlist2) self.assertNotEqual(hash(playlist1), hash(playlist2)) - def test_ne_uri(self): + def test_ne_last_modified(self): playlist1 = Playlist(last_modified=1) playlist2 = Playlist(last_modified=2) self.assertNotEqual(playlist1, playlist2) self.assertNotEqual(hash(playlist1), hash(playlist2)) def test_ne(self): - playlist1 = Playlist(uri=u'uri1', name=u'name2', - tracks=[Track(uri=u'uri1')], last_modified=1) - playlist2 = Playlist(uri=u'uri2', name=u'name2', - tracks=[Track(uri=u'uri2')], last_modified=2) + playlist1 = Playlist( + uri=u'uri1', name=u'name2', tracks=[Track(uri=u'uri1')], + last_modified=1) + playlist2 = Playlist( + uri=u'uri2', name=u'name2', tracks=[Track(uri=u'uri2')], + last_modified=2) self.assertNotEqual(playlist1, playlist2) self.assertNotEqual(hash(playlist1), hash(playlist2)) - diff --git a/tests/scanner_test.py b/tests/scanner_test.py index 91e67e11..6af48bb5 100644 --- a/tests/scanner_test.py +++ b/tests/scanner_test.py @@ -134,8 +134,8 @@ class ScannerTest(unittest.TestCase): self.data = {} def scan(self, path): - scanner = Scanner(path_to_data_dir(path), - self.data_callback, self.error_callback) + scanner = Scanner( + path_to_data_dir(path), self.data_callback, self.error_callback) scanner.start() def check(self, name, key, value): @@ -160,8 +160,9 @@ class ScannerTest(unittest.TestCase): def test_uri_is_set(self): self.scan('scanner/simple') - self.check('scanner/simple/song1.mp3', 'uri', 'file://' - + path_to_data_dir('scanner/simple/song1.mp3')) + self.check( + 'scanner/simple/song1.mp3', 'uri', + 'file://%s' % path_to_data_dir('scanner/simple/song1.mp3')) def test_duration_is_set(self): self.scan('scanner/simple') diff --git a/tests/utils/deps_test.py b/tests/utils/deps_test.py index f5aa0b1e..42c8b299 100644 --- a/tests/utils/deps_test.py +++ b/tests/utils/deps_test.py @@ -65,10 +65,12 @@ class DepsTest(unittest.TestCase): result = deps.gstreamer_info() self.assertEquals('GStreamer', result['name']) - self.assertEquals('.'.join(map(str, gst.get_gst_version())), result['version']) + self.assertEquals( + '.'.join(map(str, gst.get_gst_version())), result['version']) self.assertIn('gst', result['path']) self.assertIn('Python wrapper: gst-python', result['other']) - self.assertIn('.'.join(map(str, gst.get_pygst_version())), result['other']) + self.assertIn( + '.'.join(map(str, gst.get_pygst_version())), result['other']) self.assertIn('Relevant elements:', result['other']) def test_pykka_info(self): diff --git a/tests/utils/network/connection_test.py b/tests/utils/network/connection_test.py index 25ae1940..c51957f1 100644 --- a/tests/utils/network/connection_test.py +++ b/tests/utils/network/connection_test.py @@ -17,20 +17,23 @@ class ConnectionTest(unittest.TestCase): def test_init_ensure_nonblocking_io(self): sock = Mock(spec=socket.SocketType) - network.Connection.__init__(self.mock, Mock(), {}, sock, - (sentinel.host, sentinel.port), sentinel.timeout) + network.Connection.__init__( + self.mock, Mock(), {}, sock, (sentinel.host, sentinel.port), + sentinel.timeout) sock.setblocking.assert_called_once_with(False) def test_init_starts_actor(self): protocol = Mock(spec=network.LineProtocol) - network.Connection.__init__(self.mock, protocol, {}, Mock(), - (sentinel.host, sentinel.port), sentinel.timeout) + network.Connection.__init__( + self.mock, protocol, {}, Mock(), (sentinel.host, sentinel.port), + sentinel.timeout) protocol.start.assert_called_once_with(self.mock) def test_init_enables_recv_and_timeout(self): - network.Connection.__init__(self.mock, Mock(), {}, Mock(), - (sentinel.host, sentinel.port), sentinel.timeout) + network.Connection.__init__( + self.mock, Mock(), {}, Mock(), (sentinel.host, sentinel.port), + sentinel.timeout) self.mock.enable_recv.assert_called_once_with() self.mock.enable_timeout.assert_called_once_with() @@ -50,8 +53,8 @@ class ConnectionTest(unittest.TestCase): self.assertEqual(sentinel.port, self.mock.port) def test_init_handles_ipv6_addr(self): - addr = (sentinel.host, sentinel.port, - sentinel.flowinfo, sentinel.scopeid) + addr = ( + sentinel.host, sentinel.port, sentinel.flowinfo, sentinel.scopeid) protocol = Mock(spec=network.LineProtocol) protocol_kwargs = {} sock = Mock(spec=socket.SocketType) @@ -138,8 +141,8 @@ class ConnectionTest(unittest.TestCase): self.mock.actor_ref = Mock() self.mock.sock = Mock(spec=socket.SocketType) - network.Connection.stop(self.mock, sentinel.reason, - level=sentinel.level) + network.Connection.stop( + self.mock, sentinel.reason, level=sentinel.level) network.logger.log.assert_called_once_with( sentinel.level, sentinel.reason) @@ -160,7 +163,8 @@ class ConnectionTest(unittest.TestCase): gobject.io_add_watch.return_value = sentinel.tag network.Connection.enable_recv(self.mock) - gobject.io_add_watch.assert_called_once_with(sentinel.fileno, + gobject.io_add_watch.assert_called_once_with( + sentinel.fileno, gobject.IO_IN | gobject.IO_ERR | gobject.IO_HUP, self.mock.recv_callback) self.assertEqual(sentinel.tag, self.mock.recv_id) @@ -213,7 +217,8 @@ class ConnectionTest(unittest.TestCase): gobject.io_add_watch.return_value = sentinel.tag network.Connection.enable_send(self.mock) - gobject.io_add_watch.assert_called_once_with(sentinel.fileno, + gobject.io_add_watch.assert_called_once_with( + sentinel.fileno, gobject.IO_OUT | gobject.IO_ERR | gobject.IO_HUP, self.mock.send_callback) self.assertEqual(sentinel.tag, self.mock.send_id) @@ -270,8 +275,8 @@ class ConnectionTest(unittest.TestCase): gobject.timeout_add_seconds.return_value = sentinel.tag network.Connection.enable_timeout(self.mock) - gobject.timeout_add_seconds.assert_called_once_with(10, - self.mock.timeout_callback) + gobject.timeout_add_seconds.assert_called_once_with( + 10, self.mock.timeout_callback) self.assertEqual(sentinel.tag, self.mock.timeout_id) @patch.object(gobject, 'timeout_add_seconds', new=Mock()) @@ -359,24 +364,25 @@ class ConnectionTest(unittest.TestCase): self.mock.sock = Mock(spec=socket.SocketType) self.mock.actor_ref = Mock() - self.assertTrue(network.Connection.recv_callback(self.mock, - sentinel.fd, gobject.IO_IN | gobject.IO_ERR)) + self.assertTrue(network.Connection.recv_callback( + self.mock, sentinel.fd, gobject.IO_IN | gobject.IO_ERR)) self.mock.stop.assert_called_once_with(any_unicode) def test_recv_callback_respects_io_hup(self): self.mock.sock = Mock(spec=socket.SocketType) self.mock.actor_ref = Mock() - self.assertTrue(network.Connection.recv_callback(self.mock, - sentinel.fd, gobject.IO_IN | gobject.IO_HUP)) + self.assertTrue(network.Connection.recv_callback( + self.mock, sentinel.fd, gobject.IO_IN | gobject.IO_HUP)) self.mock.stop.assert_called_once_with(any_unicode) def test_recv_callback_respects_io_hup_and_io_err(self): self.mock.sock = Mock(spec=socket.SocketType) self.mock.actor_ref = Mock() - self.assertTrue(network.Connection.recv_callback(self.mock, - sentinel.fd, gobject.IO_IN | gobject.IO_HUP | gobject.IO_ERR)) + self.assertTrue(network.Connection.recv_callback( + self.mock, sentinel.fd, + gobject.IO_IN | gobject.IO_HUP | gobject.IO_ERR)) self.mock.stop.assert_called_once_with(any_unicode) def test_recv_callback_sends_data_to_actor(self): @@ -432,8 +438,8 @@ class ConnectionTest(unittest.TestCase): self.mock.actor_ref = Mock() self.mock.send_buffer = '' - self.assertTrue(network.Connection.send_callback(self.mock, - sentinel.fd, gobject.IO_IN | gobject.IO_ERR)) + self.assertTrue(network.Connection.send_callback( + self.mock, sentinel.fd, gobject.IO_IN | gobject.IO_ERR)) self.mock.stop.assert_called_once_with(any_unicode) def test_send_callback_respects_io_hup(self): @@ -443,8 +449,8 @@ class ConnectionTest(unittest.TestCase): self.mock.actor_ref = Mock() self.mock.send_buffer = '' - self.assertTrue(network.Connection.send_callback(self.mock, - sentinel.fd, gobject.IO_IN | gobject.IO_HUP)) + self.assertTrue(network.Connection.send_callback( + self.mock, sentinel.fd, gobject.IO_IN | gobject.IO_HUP)) self.mock.stop.assert_called_once_with(any_unicode) def test_send_callback_respects_io_hup_and_io_err(self): @@ -454,8 +460,9 @@ class ConnectionTest(unittest.TestCase): self.mock.actor_ref = Mock() self.mock.send_buffer = '' - self.assertTrue(network.Connection.send_callback(self.mock, - sentinel.fd, gobject.IO_IN | gobject.IO_HUP | gobject.IO_ERR)) + self.assertTrue(network.Connection.send_callback( + self.mock, sentinel.fd, + gobject.IO_IN | gobject.IO_HUP | gobject.IO_ERR)) self.mock.stop.assert_called_once_with(any_unicode) def test_send_callback_acquires_and_releases_lock(self): diff --git a/tests/utils/network/lineprotocol_test.py b/tests/utils/network/lineprotocol_test.py index 4ba62b8f..9a19e12e 100644 --- a/tests/utils/network/lineprotocol_test.py +++ b/tests/utils/network/lineprotocol_test.py @@ -103,8 +103,8 @@ class LineProtocolTest(unittest.TestCase): self.mock.parse_lines.return_value = ['line1', 'line2'] self.mock.decode.return_value = sentinel.decoded - network.LineProtocol.on_receive(self.mock, - {'received': 'line1\nline2\n'}) + network.LineProtocol.on_receive( + self.mock, {'received': 'line1\nline2\n'}) self.assertEqual(2, self.mock.on_line_received.call_count) def test_parse_lines_emtpy_buffer(self): diff --git a/tests/utils/network/server_test.py b/tests/utils/network/server_test.py index 268b5dbd..6090077d 100644 --- a/tests/utils/network/server_test.py +++ b/tests/utils/network/server_test.py @@ -13,8 +13,8 @@ class ServerTest(unittest.TestCase): self.mock = Mock(spec=network.Server) def test_init_calls_create_server_socket(self): - network.Server.__init__(self.mock, sentinel.host, - sentinel.port, sentinel.protocol) + network.Server.__init__( + self.mock, sentinel.host, sentinel.port, sentinel.protocol) self.mock.create_server_socket.assert_called_once_with( sentinel.host, sentinel.port) @@ -23,8 +23,8 @@ class ServerTest(unittest.TestCase): sock.fileno.return_value = sentinel.fileno self.mock.create_server_socket.return_value = sock - network.Server.__init__(self.mock, sentinel.host, - sentinel.port, sentinel.protocol) + network.Server.__init__( + self.mock, sentinel.host, sentinel.port, sentinel.protocol) self.mock.register_server_socket.assert_called_once_with( sentinel.fileno) @@ -33,17 +33,18 @@ class ServerTest(unittest.TestCase): sock.fileno.side_effect = socket.error self.mock.create_server_socket.return_value = sock - self.assertRaises(socket.error, network.Server.__init__, - self.mock, sentinel.host, sentinel.port, sentinel.protocol) + self.assertRaises( + socket.error, network.Server.__init__, self.mock, sentinel.host, + sentinel.port, sentinel.protocol) def test_init_stores_values_in_attributes(self): # This need to be a mock and no a sentinel as fileno() is called on it sock = Mock(spec=socket.SocketType) self.mock.create_server_socket.return_value = sock - network.Server.__init__(self.mock, sentinel.host, sentinel.port, - sentinel.protocol, max_connections=sentinel.max_connections, - timeout=sentinel.timeout) + network.Server.__init__( + self.mock, sentinel.host, sentinel.port, sentinel.protocol, + max_connections=sentinel.max_connections, timeout=sentinel.timeout) self.assertEqual(sentinel.protocol, self.mock.protocol) self.assertEqual(sentinel.max_connections, self.mock.max_connections) self.assertEqual(sentinel.timeout, self.mock.timeout) @@ -53,8 +54,8 @@ class ServerTest(unittest.TestCase): def test_create_server_socket_sets_up_listener(self, create_socket): sock = create_socket.return_value - network.Server.create_server_socket(self.mock, - sentinel.host, sentinel.port) + network.Server.create_server_socket( + self.mock, sentinel.host, sentinel.port) sock.setblocking.assert_called_once_with(False) sock.bind.assert_called_once_with((sentinel.host, sentinel.port)) sock.listen.assert_called_once_with(any_int) @@ -62,30 +63,33 @@ class ServerTest(unittest.TestCase): @patch.object(network, 'create_socket', new=Mock()) def test_create_server_socket_fails(self): network.create_socket.side_effect = socket.error - self.assertRaises(socket.error, network.Server.create_server_socket, - self.mock, sentinel.host, sentinel.port) + self.assertRaises( + socket.error, network.Server.create_server_socket, self.mock, + sentinel.host, sentinel.port) @patch.object(network, 'create_socket', new=Mock()) def test_create_server_bind_fails(self): sock = network.create_socket.return_value sock.bind.side_effect = socket.error - self.assertRaises(socket.error, network.Server.create_server_socket, - self.mock, sentinel.host, sentinel.port) + self.assertRaises( + socket.error, network.Server.create_server_socket, self.mock, + sentinel.host, sentinel.port) @patch.object(network, 'create_socket', new=Mock()) def test_create_server_listen_fails(self): sock = network.create_socket.return_value sock.listen.side_effect = socket.error - self.assertRaises(socket.error, network.Server.create_server_socket, - self.mock, sentinel.host, sentinel.port) + self.assertRaises( + socket.error, network.Server.create_server_socket, self.mock, + sentinel.host, sentinel.port) @patch.object(gobject, 'io_add_watch', new=Mock()) def test_register_server_socket_sets_up_io_watch(self): network.Server.register_server_socket(self.mock, sentinel.fileno) - gobject.io_add_watch.assert_called_once_with(sentinel.fileno, - gobject.IO_IN, self.mock.handle_connection) + gobject.io_add_watch.assert_called_once_with( + sentinel.fileno, gobject.IO_IN, self.mock.handle_connection) def test_handle_connection(self): self.mock.accept_connection.return_value = ( @@ -128,7 +132,8 @@ class ServerTest(unittest.TestCase): for error in (errno.EAGAIN, errno.EINTR): sock.accept.side_effect = socket.error(error, '') - self.assertRaises(network.ShouldRetrySocketCall, + self.assertRaises( + network.ShouldRetrySocketCall, network.Server.accept_connection, self.mock) # FIXME decide if this should be allowed to propegate @@ -136,8 +141,8 @@ class ServerTest(unittest.TestCase): sock = Mock(spec=socket.SocketType) self.mock.server_socket = sock sock.accept.side_effect = socket.error - self.assertRaises(socket.error, - network.Server.accept_connection, self.mock) + self.assertRaises( + socket.error, network.Server.accept_connection, self.mock) def test_maximum_connections_exceeded(self): self.mock.max_connections = 10 @@ -149,7 +154,8 @@ class ServerTest(unittest.TestCase): self.assertTrue(network.Server.maximum_connections_exceeded(self.mock)) self.mock.number_of_connections.return_value = 9 - self.assertFalse(network.Server.maximum_connections_exceeded(self.mock)) + self.assertFalse( + network.Server.maximum_connections_exceeded(self.mock)) @patch('pykka.registry.ActorRegistry.get_by_class') def test_number_of_connections(self, get_by_class): @@ -168,20 +174,21 @@ class ServerTest(unittest.TestCase): self.mock.timeout = sentinel.timeout network.Server.init_connection(self.mock, sentinel.sock, sentinel.addr) - network.Connection.assert_called_once_with(sentinel.protocol, {}, - sentinel.sock, sentinel.addr, sentinel.timeout) + network.Connection.assert_called_once_with( + sentinel.protocol, {}, sentinel.sock, sentinel.addr, + sentinel.timeout) def test_reject_connection(self): sock = Mock(spec=socket.SocketType) - network.Server.reject_connection(self.mock, sock, - (sentinel.host, sentinel.port)) + network.Server.reject_connection( + self.mock, sock, (sentinel.host, sentinel.port)) sock.close.assert_called_once_with() def test_reject_connection_error(self): sock = Mock(spec=socket.SocketType) sock.close.side_effect = socket.error - network.Server.reject_connection(self.mock, sock, - (sentinel.host, sentinel.port)) + network.Server.reject_connection( + self.mock, sock, (sentinel.host, sentinel.port)) sock.close.assert_called_once_with() diff --git a/tests/utils/network/utils_test.py b/tests/utils/network/utils_test.py index 1e11673e..f28aeb4b 100644 --- a/tests/utils/network/utils_test.py +++ b/tests/utils/network/utils_test.py @@ -42,15 +42,15 @@ class CreateSocketTest(unittest.TestCase): @patch('socket.socket') def test_ipv4_socket(self, socket_mock): network.create_socket() - self.assertEqual(socket_mock.call_args[0], - (socket.AF_INET, socket.SOCK_STREAM)) + self.assertEqual( + socket_mock.call_args[0], (socket.AF_INET, socket.SOCK_STREAM)) @patch('mopidy.utils.network.has_ipv6', True) @patch('socket.socket') def test_ipv6_socket(self, socket_mock): network.create_socket() - self.assertEqual(socket_mock.call_args[0], - (socket.AF_INET6, socket.SOCK_STREAM)) + self.assertEqual( + socket_mock.call_args[0], (socket.AF_INET6, socket.SOCK_STREAM)) @unittest.SkipTest def test_ipv6_only_is_set(self): diff --git a/tests/utils/path_test.py b/tests/utils/path_test.py index d782aa15..91951ac7 100644 --- a/tests/utils/path_test.py +++ b/tests/utils/path_test.py @@ -108,7 +108,7 @@ class UriToPathTest(unittest.TestCase): def test_unicode_in_uri(self): if sys.platform == 'win32': - result = path.uri_to_path( 'file:///C://%C3%A6%C3%B8%C3%A5') + result = path.uri_to_path('file:///C://%C3%A6%C3%B8%C3%A5') self.assertEqual(result, u'C:/æøå') else: result = path.uri_to_path(u'file:///tmp/%C3%A6%C3%B8%C3%A5') @@ -125,11 +125,9 @@ class SplitPathTest(unittest.TestCase): def test_folders(self): self.assertEqual(['foo', 'bar', 'baz'], path.split_path('foo/bar/baz')) - def test_folders(self): - self.assertEqual(['foo', 'bar', 'baz'], path.split_path('foo/bar/baz')) - def test_initial_slash_is_ignored(self): - self.assertEqual(['foo', 'bar', 'baz'], path.split_path('/foo/bar/baz')) + self.assertEqual( + ['foo', 'bar', 'baz'], path.split_path('/foo/bar/baz')) def test_only_slash(self): self.assertEqual([], path.split_path('/')) @@ -145,17 +143,20 @@ class ExpandPathTest(unittest.TestCase): self.assertEqual('/tmp/foo', path.expand_path('/tmp/foo')) def test_home_dir_expansion(self): - self.assertEqual(os.path.expanduser('~/foo'), path.expand_path('~/foo')) + self.assertEqual( + os.path.expanduser('~/foo'), path.expand_path('~/foo')) def test_abspath(self): self.assertEqual(os.path.abspath('./foo'), path.expand_path('./foo')) def test_xdg_subsititution(self): - self.assertEqual(glib.get_user_data_dir() + '/foo', + self.assertEqual( + glib.get_user_data_dir() + '/foo', path.expand_path('$XDG_DATA_DIR/foo')) def test_xdg_subsititution_unknown(self): - self.assertEqual('/tmp/$XDG_INVALID_DIR/foo', + self.assertEqual( + '/tmp/$XDG_INVALID_DIR/foo', path.expand_path('/tmp/$XDG_INVALID_DIR/foo')) @@ -177,8 +178,8 @@ class FindFilesTest(unittest.TestCase): def test_names_are_unicode(self): is_unicode = lambda f: isinstance(f, unicode) for name in self.find(''): - self.assert_(is_unicode(name), - '%s is not unicode object' % repr(name)) + self.assert_( + is_unicode(name), '%s is not unicode object' % repr(name)) def test_ignores_hidden_folders(self): self.assertEqual(self.find('.hidden'), []) diff --git a/tests/utils/settings_test.py b/tests/utils/settings_test.py index cf476c24..bbeda20c 100644 --- a/tests/utils/settings_test.py +++ b/tests/utils/settings_test.py @@ -19,41 +19,47 @@ class ValidateSettingsTest(unittest.TestCase): self.assertEqual(result, {}) def test_unknown_setting_returns_error(self): - result = setting_utils.validate_settings(self.defaults, - {'MPD_SERVER_HOSTNMAE': '127.0.0.1'}) - self.assertEqual(result['MPD_SERVER_HOSTNMAE'], + result = setting_utils.validate_settings( + self.defaults, {'MPD_SERVER_HOSTNMAE': '127.0.0.1'}) + self.assertEqual( + result['MPD_SERVER_HOSTNMAE'], u'Unknown setting. Did you mean MPD_SERVER_HOSTNAME?') def test_not_renamed_setting_returns_error(self): - result = setting_utils.validate_settings(self.defaults, - {'SERVER_HOSTNAME': '127.0.0.1'}) - self.assertEqual(result['SERVER_HOSTNAME'], + result = setting_utils.validate_settings( + self.defaults, {'SERVER_HOSTNAME': '127.0.0.1'}) + self.assertEqual( + result['SERVER_HOSTNAME'], u'Deprecated setting. Use MPD_SERVER_HOSTNAME.') def test_unneeded_settings_returns_error(self): - result = setting_utils.validate_settings(self.defaults, - {'SPOTIFY_LIB_APPKEY': '/tmp/foo'}) - self.assertEqual(result['SPOTIFY_LIB_APPKEY'], + result = setting_utils.validate_settings( + self.defaults, {'SPOTIFY_LIB_APPKEY': '/tmp/foo'}) + self.assertEqual( + result['SPOTIFY_LIB_APPKEY'], u'Deprecated setting. It may be removed.') def test_deprecated_setting_value_returns_error(self): - result = setting_utils.validate_settings(self.defaults, + result = setting_utils.validate_settings( + self.defaults, {'BACKENDS': ('mopidy.backends.despotify.DespotifyBackend',)}) - self.assertEqual(result['BACKENDS'], - u'Deprecated setting value. ' + - '"mopidy.backends.despotify.DespotifyBackend" is no longer ' + - 'available.') + self.assertEqual( + result['BACKENDS'], + u'Deprecated setting value. ' + u'"mopidy.backends.despotify.DespotifyBackend" is no longer ' + u'available.') def test_unavailable_bitrate_setting_returns_error(self): - result = setting_utils.validate_settings(self.defaults, - {'SPOTIFY_BITRATE': 50}) - self.assertEqual(result['SPOTIFY_BITRATE'], - u'Unavailable Spotify bitrate. ' + + result = setting_utils.validate_settings( + self.defaults, {'SPOTIFY_BITRATE': 50}) + self.assertEqual( + result['SPOTIFY_BITRATE'], + u'Unavailable Spotify bitrate. ' u'Available bitrates are 96, 160, and 320.') def test_two_errors_are_both_reported(self): - result = setting_utils.validate_settings(self.defaults, - {'FOO': '', 'BAR': ''}) + result = setting_utils.validate_settings( + self.defaults, {'FOO': '', 'BAR': ''}) self.assertEqual(len(result), 2) def test_masks_value_if_secret(self): @@ -61,11 +67,13 @@ class ValidateSettingsTest(unittest.TestCase): self.assertEqual(u'********', secret) def test_does_not_mask_value_if_not_secret(self): - not_secret = setting_utils.mask_value_if_secret('SPOTIFY_USERNAME', 'foo') + not_secret = setting_utils.mask_value_if_secret( + 'SPOTIFY_USERNAME', 'foo') self.assertEqual('foo', not_secret) def test_does_not_mask_value_if_none(self): - not_secret = setting_utils.mask_value_if_secret('SPOTIFY_USERNAME', None) + not_secret = setting_utils.mask_value_if_secret( + 'SPOTIFY_USERNAME', None) self.assertEqual(None, not_secret) @@ -80,7 +88,7 @@ class SettingsProxyTest(unittest.TestCase): def test_getattr_raises_error_on_missing_setting(self): try: - _ = self.settings.TEST + self.settings.TEST self.fail(u'Should raise exception') except mopidy.SettingsError as e: self.assertEqual(u'Setting "TEST" is not set.', e.message) @@ -88,7 +96,7 @@ class SettingsProxyTest(unittest.TestCase): def test_getattr_raises_error_on_empty_setting(self): self.settings.TEST = u'' try: - _ = self.settings.TEST + self.settings.TEST self.fail(u'Should raise exception') except mopidy.SettingsError as e: self.assertEqual(u'Setting "TEST" is empty.', e.message) @@ -207,15 +215,19 @@ class FormatSettingListTest(unittest.TestCase): def test_short_values_are_not_pretty_printed(self): self.settings.FRONTEND = (u'mopidy.frontends.mpd.MpdFrontend',) result = setting_utils.format_settings_list(self.settings) - self.assertIn("FRONTEND: (u'mopidy.frontends.mpd.MpdFrontend',)", result) + self.assertIn( + "FRONTEND: (u'mopidy.frontends.mpd.MpdFrontend',)", result) def test_long_values_are_pretty_printed(self): - self.settings.FRONTEND = (u'mopidy.frontends.mpd.MpdFrontend', + self.settings.FRONTEND = ( + u'mopidy.frontends.mpd.MpdFrontend', u'mopidy.frontends.lastfm.LastfmFrontend') result = setting_utils.format_settings_list(self.settings) - self.assert_("""FRONTEND: - (u'mopidy.frontends.mpd.MpdFrontend', - u'mopidy.frontends.lastfm.LastfmFrontend')""" in result, result) + self.assertIn( + "FRONTEND: \n" + " (u'mopidy.frontends.mpd.MpdFrontend',\n" + " u'mopidy.frontends.lastfm.LastfmFrontend')", + result) class DidYouMeanTest(unittest.TestCase):