diff --git a/tests/backends/base/current_playlist.py b/tests/backends/base/current_playlist.py index bfc0a254..430e4c40 100644 --- a/tests/backends/base/current_playlist.py +++ b/tests/backends/base/current_playlist.py @@ -206,7 +206,7 @@ class CurrentPlaylistControllerTest(object): version = self.controller.version self.controller.remove(uri=track1.uri) self.assert_(version < self.controller.version) - self.assert_(track1 not in self.controller.tracks) + self.assertNotIn(track1, self.controller.tracks) self.assertEqual(track2, self.controller.tracks[1]) @populate_playlist diff --git a/tests/backends/base/playback.py b/tests/backends/base/playback.py index b9661df9..1e434e35 100644 --- a/tests/backends/base/playback.py +++ b/tests/backends/base/playback.py @@ -274,7 +274,7 @@ class PlaybackControllerTest(object): self.playback.consume = True self.playback.play() self.playback.next() - self.assert_(self.tracks[0] in self.backend.current_playlist.tracks) + self.assertIn(self.tracks[0], self.backend.current_playlist.tracks) @populate_playlist def test_next_with_single_and_repeat(self): @@ -411,7 +411,7 @@ class PlaybackControllerTest(object): self.playback.consume = True self.playback.play() self.playback.on_end_of_track() - self.assert_(self.tracks[0] not in self.backend.current_playlist.tracks) + self.assertNotIn(self.tracks[0], self.backend.current_playlist.tracks) @populate_playlist def test_end_of_track_with_random(self): @@ -855,7 +855,7 @@ class PlaybackControllerTest(object): self.playback.play() played = [] for _ in self.tracks: - self.assert_(self.playback.current_track not in played) + self.assertNotIn(self.playback.current_track, played) played.append(self.playback.current_track) self.playback.next() diff --git a/tests/backends/base/stored_playlists.py b/tests/backends/base/stored_playlists.py index 54315e62..1e575b9e 100644 --- a/tests/backends/base/stored_playlists.py +++ b/tests/backends/base/stored_playlists.py @@ -30,7 +30,7 @@ class StoredPlaylistsControllerTest(object): def test_create_in_playlists(self): playlist = self.stored.create('test') self.assert_(self.stored.playlists) - self.assert_(playlist in self.stored.playlists) + self.assertIn(playlist, self.stored.playlists) def test_playlists_empty_to_start_with(self): self.assert_(not self.stored.playlists) @@ -101,7 +101,7 @@ class StoredPlaylistsControllerTest(object): # FIXME should we handle playlists without names? playlist = Playlist(name='test') self.stored.save(playlist) - self.assert_(playlist in self.stored.playlists) + self.assertIn(playlist, self.stored.playlists) @unittest.SkipTest def test_playlist_with_unknown_track(self): diff --git a/tests/backends/local/playback_test.py b/tests/backends/local/playback_test.py index 4dede6ad..c167fbcc 100644 --- a/tests/backends/local/playback_test.py +++ b/tests/backends/local/playback_test.py @@ -35,7 +35,7 @@ class LocalPlaybackControllerTest(PlaybackControllerTest, unittest.TestCase): self.backend.current_playlist.add(track) def test_uri_scheme(self): - self.assert_('file' in self.backend.uri_schemes) + self.assertIn('file', self.backend.uri_schemes) def test_play_mp3(self): self.add_track('blank.mp3') diff --git a/tests/frontends/mpd/dispatcher_test.py b/tests/frontends/mpd/dispatcher_test.py index 63f6d299..9f05d7dd 100644 --- a/tests/frontends/mpd/dispatcher_test.py +++ b/tests/frontends/mpd/dispatcher_test.py @@ -37,7 +37,7 @@ class MpdDispatcherTest(unittest.TestCase): expected_handler (handler, kwargs) = self.dispatcher._find_handler('known_command an_arg') self.assertEqual(handler, expected_handler) - self.assert_('arg1' in kwargs) + self.assertIn('arg1', kwargs) self.assertEqual(kwargs['arg1'], 'an_arg') def test_handling_unknown_request_yields_error(self): @@ -48,5 +48,5 @@ class MpdDispatcherTest(unittest.TestCase): expected = 'magic' request_handlers['known request'] = lambda x: expected result = self.dispatcher.handle_request('known request') - self.assert_(u'OK' in result) - self.assert_(expected in result) + self.assertIn(u'OK', result) + self.assertIn(expected, result) diff --git a/tests/frontends/mpd/protocol/__init__.py b/tests/frontends/mpd/protocol/__init__.py index b39ded01..3b8fbe33 100644 --- a/tests/frontends/mpd/protocol/__init__.py +++ b/tests/frontends/mpd/protocol/__init__.py @@ -42,7 +42,7 @@ class BaseTestCase(unittest.TestCase): self.assertEqual([], self.connection.response) def assertInResponse(self, value): - self.assert_(value in self.connection.response, u'Did not find %s ' + self.assertIn(value, self.connection.response, u'Did not find %s ' 'in %s' % (repr(value), repr(self.connection.response))) def assertOnceInResponse(self, value): @@ -51,7 +51,7 @@ class BaseTestCase(unittest.TestCase): (repr(value), repr(self.connection.response))) def assertNotInResponse(self, value): - self.assert_(value not in self.connection.response, u'Found %s in %s' % + self.assertNotIn(value, self.connection.response, u'Found %s in %s' % (repr(value), repr(self.connection.response))) def assertEqualResponse(self, value): diff --git a/tests/frontends/mpd/protocol/command_list_test.py b/tests/frontends/mpd/protocol/command_list_test.py index a81725ad..65b051d3 100644 --- a/tests/frontends/mpd/protocol/command_list_test.py +++ b/tests/frontends/mpd/protocol/command_list_test.py @@ -21,7 +21,7 @@ class CommandListsTest(protocol.BaseTestCase): self.assertEqual([], self.dispatcher.command_list) self.assertEqual(False, self.dispatcher.command_list_ok) self.sendRequest(u'ping') - self.assert_(u'ping' in self.dispatcher.command_list) + self.assertIn(u'ping', self.dispatcher.command_list) self.sendRequest(u'command_list_end') self.assertInResponse(u'OK') self.assertEqual(False, self.dispatcher.command_list) @@ -42,7 +42,7 @@ class CommandListsTest(protocol.BaseTestCase): self.assertEqual([], self.dispatcher.command_list) self.assertEqual(True, self.dispatcher.command_list_ok) self.sendRequest(u'ping') - self.assert_(u'ping' in self.dispatcher.command_list) + self.assertIn(u'ping', self.dispatcher.command_list) self.sendRequest(u'command_list_end') self.assertInResponse(u'list_OK') self.assertInResponse(u'OK') diff --git a/tests/frontends/mpd/serializer_test.py b/tests/frontends/mpd/serializer_test.py index a20abaed..e6cd80e2 100644 --- a/tests/frontends/mpd/serializer_test.py +++ b/tests/frontends/mpd/serializer_test.py @@ -31,66 +31,66 @@ class TrackMpdFormatTest(unittest.TestCase): def test_track_to_mpd_format_for_empty_track(self): result = translator.track_to_mpd_format(Track()) - self.assert_(('file', '') in result) - self.assert_(('Time', 0) in result) - self.assert_(('Artist', '') in result) - self.assert_(('Title', '') in result) - self.assert_(('Album', '') in result) - self.assert_(('Track', 0) in result) - self.assert_(('Date', '') in result) + self.assertIn(('file', ''), result) + self.assertIn(('Time', 0), result) + self.assertIn(('Artist', ''), result) + self.assertIn(('Title', ''), result) + self.assertIn(('Album', ''), result) + self.assertIn(('Track', 0), result) + self.assertIn(('Date', ''), result) self.assertEqual(len(result), 7) def test_track_to_mpd_format_with_position(self): result = translator.track_to_mpd_format(Track(), position=1) - self.assert_(('Pos', 1) not in result) + self.assertNotIn(('Pos', 1), result) def test_track_to_mpd_format_with_cpid(self): result = translator.track_to_mpd_format(CpTrack(1, Track())) - self.assert_(('Id', 1) not in result) + 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) - self.assert_(('Pos', 1) in result) - self.assert_(('Id', 2) in result) + self.assertIn(('Pos', 1), result) + self.assertIn(('Id', 2), result) def test_track_to_mpd_format_for_nonempty_track(self): result = translator.track_to_mpd_format( CpTrack(122, self.track), position=9) - self.assert_(('file', 'a uri') in result) - self.assert_(('Time', 137) in result) - self.assert_(('Artist', 'an artist') in result) - self.assert_(('Title', 'a name') in result) - self.assert_(('Album', 'an album') in result) - self.assert_(('AlbumArtist', 'an other artist') in result) - self.assert_(('Track', '7/13') in result) - self.assert_(('Date', datetime.date(1977, 1, 1)) in result) - self.assert_(('Pos', 9) in result) - self.assert_(('Id', 122) in result) + self.assertIn(('file', 'a uri'), result) + self.assertIn(('Time', 137), result) + self.assertIn(('Artist', 'an artist'), result) + self.assertIn(('Title', 'a name'), result) + self.assertIn(('Album', 'an album'), result) + self.assertIn(('AlbumArtist', 'an other artist'), result) + self.assertIn(('Track', '7/13'), result) + self.assertIn(('Date', datetime.date(1977, 1, 1)), result) + self.assertIn(('Pos', 9), result) + self.assertIn(('Id', 122), result) self.assertEqual(len(result), 10) def test_track_to_mpd_format_musicbrainz_trackid(self): track = self.track.copy(musicbrainz_id='foo') result = translator.track_to_mpd_format(track) - self.assert_(('MUSICBRAINZ_TRACKID', 'foo') in result) + self.assertIn(('MUSICBRAINZ_TRACKID', 'foo'), result) def test_track_to_mpd_format_musicbrainz_albumid(self): album = self.track.album.copy(musicbrainz_id='foo') track = self.track.copy(album=album) result = translator.track_to_mpd_format(track) - self.assert_(('MUSICBRAINZ_ALBUMID', 'foo') in result) + self.assertIn(('MUSICBRAINZ_ALBUMID', 'foo'), result) def test_track_to_mpd_format_musicbrainz_albumid(self): artist = list(self.track.artists)[0].copy(musicbrainz_id='foo') album = self.track.album.copy(artists=[artist]) track = self.track.copy(album=album) result = translator.track_to_mpd_format(track) - self.assert_(('MUSICBRAINZ_ALBUMARTISTID', 'foo') in result) + self.assertIn(('MUSICBRAINZ_ALBUMARTISTID', 'foo'), result) def test_track_to_mpd_format_musicbrainz_artistid(self): artist = list(self.track.artists)[0].copy(musicbrainz_id='foo') track = self.track.copy(artists=[artist]) result = translator.track_to_mpd_format(track) - self.assert_(('MUSICBRAINZ_ARTISTID', 'foo') in result) + self.assertIn(('MUSICBRAINZ_ARTISTID', 'foo'), result) def test_artists_to_mpd_format(self): artists = [Artist(name=u'ABBA'), Artist(name=u'Beatles')] diff --git a/tests/frontends/mpd/status_test.py b/tests/frontends/mpd/status_test.py index 455dba45..2bc3488b 100644 --- a/tests/frontends/mpd/status_test.py +++ b/tests/frontends/mpd/status_test.py @@ -26,123 +26,123 @@ class StatusHandlerTest(unittest.TestCase): def test_stats_method(self): result = status.stats(self.context) - self.assert_('artists' in result) + self.assertIn('artists', result) self.assert_(int(result['artists']) >= 0) - self.assert_('albums' in result) + self.assertIn('albums', result) self.assert_(int(result['albums']) >= 0) - self.assert_('songs' in result) + self.assertIn('songs', result) self.assert_(int(result['songs']) >= 0) - self.assert_('uptime' in result) + self.assertIn('uptime', result) self.assert_(int(result['uptime']) >= 0) - self.assert_('db_playtime' in result) + self.assertIn('db_playtime', result) self.assert_(int(result['db_playtime']) >= 0) - self.assert_('db_update' in result) + self.assertIn('db_update', result) self.assert_(int(result['db_update']) >= 0) - self.assert_('playtime' in result) + self.assertIn('playtime', result) self.assert_(int(result['playtime']) >= 0) def test_status_method_contains_volume_with_na_value(self): result = dict(status.status(self.context)) - self.assert_('volume' in result) + self.assertIn('volume', result) self.assertEqual(int(result['volume']), -1) def test_status_method_contains_volume(self): self.backend.playback.volume = 17 result = dict(status.status(self.context)) - self.assert_('volume' in result) + self.assertIn('volume', result) self.assertEqual(int(result['volume']), 17) def test_status_method_contains_repeat_is_0(self): result = dict(status.status(self.context)) - self.assert_('repeat' in result) + self.assertIn('repeat', result) self.assertEqual(int(result['repeat']), 0) def test_status_method_contains_repeat_is_1(self): self.backend.playback.repeat = 1 result = dict(status.status(self.context)) - self.assert_('repeat' in result) + self.assertIn('repeat', result) self.assertEqual(int(result['repeat']), 1) def test_status_method_contains_random_is_0(self): result = dict(status.status(self.context)) - self.assert_('random' in result) + self.assertIn('random', result) self.assertEqual(int(result['random']), 0) def test_status_method_contains_random_is_1(self): self.backend.playback.random = 1 result = dict(status.status(self.context)) - self.assert_('random' in result) + self.assertIn('random', result) self.assertEqual(int(result['random']), 1) def test_status_method_contains_single(self): result = dict(status.status(self.context)) - self.assert_('single' in result) - self.assert_(int(result['single']) in (0, 1)) + self.assertIn('single', result) + self.assertIn(int(result['single']), (0, 1)) def test_status_method_contains_consume_is_0(self): result = dict(status.status(self.context)) - self.assert_('consume' in result) + self.assertIn('consume', result) self.assertEqual(int(result['consume']), 0) def test_status_method_contains_consume_is_1(self): self.backend.playback.consume = 1 result = dict(status.status(self.context)) - self.assert_('consume' in result) + self.assertIn('consume', result) self.assertEqual(int(result['consume']), 1) def test_status_method_contains_playlist(self): result = dict(status.status(self.context)) - self.assert_('playlist' in result) - self.assert_(int(result['playlist']) in xrange(0, 2**31 - 1)) + self.assertIn('playlist', result) + self.assertIn(int(result['playlist']), xrange(0, 2**31 - 1)) def test_status_method_contains_playlistlength(self): result = dict(status.status(self.context)) - self.assert_('playlistlength' in result) + self.assertIn('playlistlength', result) self.assert_(int(result['playlistlength']) >= 0) def test_status_method_contains_xfade(self): result = dict(status.status(self.context)) - self.assert_('xfade' in result) + self.assertIn('xfade', result) self.assert_(int(result['xfade']) >= 0) def test_status_method_contains_state_is_play(self): self.backend.playback.state = PLAYING result = dict(status.status(self.context)) - self.assert_('state' in result) + self.assertIn('state', result) self.assertEqual(result['state'], 'play') def test_status_method_contains_state_is_stop(self): self.backend.playback.state = STOPPED result = dict(status.status(self.context)) - self.assert_('state' in result) + self.assertIn('state', result) self.assertEqual(result['state'], 'stop') def test_status_method_contains_state_is_pause(self): self.backend.playback.state = PLAYING self.backend.playback.state = PAUSED result = dict(status.status(self.context)) - self.assert_('state' in result) + self.assertIn('state', result) self.assertEqual(result['state'], 'pause') def test_status_method_when_playlist_loaded_contains_song(self): self.backend.current_playlist.append([Track()]) self.backend.playback.play() result = dict(status.status(self.context)) - self.assert_('song' in result) + self.assertIn('song', result) self.assert_(int(result['song']) >= 0) def test_status_method_when_playlist_loaded_contains_cpid_as_songid(self): self.backend.current_playlist.append([Track()]) self.backend.playback.play() result = dict(status.status(self.context)) - self.assert_('songid' in result) + self.assertIn('songid', result) self.assertEqual(int(result['songid']), 0) def test_status_method_when_playing_contains_time_with_no_length(self): self.backend.current_playlist.append([Track(length=None)]) self.backend.playback.play() result = dict(status.status(self.context)) - self.assert_('time' in result) + self.assertIn('time', result) (position, total) = result['time'].split(':') position = int(position) total = int(total) @@ -152,7 +152,7 @@ class StatusHandlerTest(unittest.TestCase): self.backend.current_playlist.append([Track(length=10000)]) self.backend.playback.play() result = dict(status.status(self.context)) - self.assert_('time' in result) + self.assertIn('time', result) (position, total) = result['time'].split(':') position = int(position) total = int(total) @@ -162,19 +162,19 @@ class StatusHandlerTest(unittest.TestCase): self.backend.playback.state = PAUSED self.backend.playback.play_time_accumulated = 59123 result = dict(status.status(self.context)) - self.assert_('elapsed' in result) + self.assertIn('elapsed', result) self.assertEqual(result['elapsed'], '59.123') def test_status_method_when_starting_playing_contains_elapsed_zero(self): self.backend.playback.state = PAUSED self.backend.playback.play_time_accumulated = 123 # Less than 1000ms result = dict(status.status(self.context)) - self.assert_('elapsed' in result) + self.assertIn('elapsed', result) self.assertEqual(result['elapsed'], '0.123') def test_status_method_when_playing_contains_bitrate(self): self.backend.current_playlist.append([Track(bitrate=320)]) self.backend.playback.play() result = dict(status.status(self.context)) - self.assert_('bitrate' in result) + self.assertIn('bitrate', result) self.assertEqual(int(result['bitrate']), 320) diff --git a/tests/frontends/mpris/player_interface_test.py b/tests/frontends/mpris/player_interface_test.py index a6415b2f..db7f9265 100644 --- a/tests/frontends/mpris/player_interface_test.py +++ b/tests/frontends/mpris/player_interface_test.py @@ -141,7 +141,7 @@ 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.assert_('mpris:trackid' in result.keys()) + self.assertIn('mpris:trackid', result.keys()) self.assertEquals(result['mpris:trackid'], '') def test_get_metadata_has_trackid_based_on_cpid(self): diff --git a/tests/help_test.py b/tests/help_test.py index 1fa22c2f..a2803b72 100644 --- a/tests/help_test.py +++ b/tests/help_test.py @@ -13,18 +13,18 @@ class HelpTest(unittest.TestCase): args = [sys.executable, mopidy_dir, '--help'] process = subprocess.Popen(args, stdout=subprocess.PIPE) output = process.communicate()[0] - self.assert_('--version' in output) - self.assert_('--help' in output) - self.assert_('--help-gst' in output) - self.assert_('--interactive' in output) - self.assert_('--quiet' in output) - self.assert_('--verbose' in output) - self.assert_('--save-debug-log' in output) - self.assert_('--list-settings' in output) + self.assertIn('--version', output) + self.assertIn('--help', output) + self.assertIn('--help-gst', output) + self.assertIn('--interactive', output) + self.assertIn('--quiet', output) + self.assertIn('--verbose', output) + self.assertIn('--save-debug-log', output) + self.assertIn('--list-settings', output) def test_help_gst_has_gstreamer_options(self): mopidy_dir = os.path.dirname(mopidy.__file__) args = [sys.executable, mopidy_dir, '--help-gst'] process = subprocess.Popen(args, stdout=subprocess.PIPE) output = process.communicate()[0] - self.assert_('--gst-version' in output) + self.assertIn('--gst-version', output) diff --git a/tests/models_test.py b/tests/models_test.py index af90c5bd..779d1a4b 100644 --- a/tests/models_test.py +++ b/tests/models_test.py @@ -43,7 +43,7 @@ class GenericCopyTets(unittest.TestCase): artist2 = Artist(name='bar') track = Track(artists=[artist1]) copy = track.copy(artists=[artist2]) - self.assert_(artist2 in copy.artists) + self.assertIn(artist2, copy.artists) def test_copying_track_with_invalid_key(self): test = lambda: Track().copy(invalid_key=True) @@ -155,7 +155,7 @@ class AlbumTest(unittest.TestCase): def test_artists(self): artist = Artist() album = Album(artists=[artist]) - self.assert_(artist in album.artists) + self.assertIn(artist, album.artists) self.assertRaises(AttributeError, setattr, album, 'artists', None) def test_num_tracks(self): diff --git a/tests/utils/init_test.py b/tests/utils/init_test.py index f232e2ef..bdd0adc5 100644 --- a/tests/utils/init_test.py +++ b/tests/utils/init_test.py @@ -20,7 +20,7 @@ class GetClassTest(unittest.TestCase): try: utils.get_class('foo.bar.Baz') except ImportError as e: - self.assert_('foo.bar.Baz' in str(e)) + self.assertIn('foo.bar.Baz', str(e)) def test_loading_existing_class(self): cls = utils.get_class('unittest.TestCase') diff --git a/tests/utils/settings_test.py b/tests/utils/settings_test.py index 7d104969..cf476c24 100644 --- a/tests/utils/settings_test.py +++ b/tests/utils/settings_test.py @@ -107,7 +107,7 @@ class SettingsProxyTest(unittest.TestCase): def test_setattr_updates_runtime_settings(self): self.settings.TEST = 'test' - self.assert_('TEST' in self.settings.runtime) + self.assertIn('TEST', self.settings.runtime) def test_setattr_updates_runtime_with_value(self): self.settings.TEST = 'test' @@ -181,34 +181,33 @@ class FormatSettingListTest(unittest.TestCase): def test_contains_the_setting_name(self): self.settings.TEST = u'test' result = setting_utils.format_settings_list(self.settings) - self.assert_('TEST:' in result, result) + self.assertIn('TEST:', result, result) def test_repr_of_a_string_value(self): self.settings.TEST = u'test' result = setting_utils.format_settings_list(self.settings) - self.assert_("TEST: u'test'" in result, result) + self.assertIn("TEST: u'test'", result, result) def test_repr_of_an_int_value(self): self.settings.TEST = 123 result = setting_utils.format_settings_list(self.settings) - self.assert_("TEST: 123" in result, result) + self.assertIn("TEST: 123", result, result) def test_repr_of_a_tuple_value(self): self.settings.TEST = (123, u'abc') result = setting_utils.format_settings_list(self.settings) - self.assert_("TEST: (123, u'abc')" in result, result) + self.assertIn("TEST: (123, u'abc')", result, result) def test_passwords_are_masked(self): self.settings.TEST_PASSWORD = u'secret' result = setting_utils.format_settings_list(self.settings) - self.assert_("TEST_PASSWORD: u'secret'" not in result, result) - self.assert_("TEST_PASSWORD: u'********'" in result, result) + self.assertNotIn("TEST_PASSWORD: u'secret'", result, result) + self.assertIn("TEST_PASSWORD: u'********'", result, result) 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.assert_("FRONTEND: (u'mopidy.frontends.mpd.MpdFrontend',)" in result, - 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', diff --git a/tests/version_test.py b/tests/version_test.py index 26045ac1..85b182f0 100644 --- a/tests/version_test.py +++ b/tests/version_test.py @@ -31,10 +31,10 @@ class VersionTest(unittest.TestCase): self.assert_(SV(__version__) < SV('0.8.0')) def test_get_platform_contains_platform(self): - self.assert_(platform.platform() in get_platform()) + self.assertIn(platform.platform(), get_platform()) def test_get_python_contains_python_implementation(self): - self.assert_(platform.python_implementation() in get_python()) + self.assertIn(platform.python_implementation(), get_python()) def test_get_python_contains_python_version(self): - self.assert_(platform.python_version() in get_python()) + self.assertIn(platform.python_version(), get_python())