andpp/mopidy
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Use assertIn and assertNotIn in tests

Browse Source
This commit is contained in:
Stein Magnus Jodal 2012-09-14 23:59:57 +02:00
parent 1443114204
commit a8d1d41ab3
15 changed files with 94 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/backends/base/current_playlist.py
View File

@ -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

6
tests/backends/base/playback.py
View File

@ -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()

4
tests/backends/base/stored_playlists.py
View File

@ -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):

2
tests/backends/local/playback_test.py
View File

@ -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')

6
tests/frontends/mpd/dispatcher_test.py
View File

@ -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)

4
tests/frontends/mpd/protocol/__init__.py
View File

@ -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):

4
tests/frontends/mpd/protocol/command_list_test.py
View File

@ -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')

50
tests/frontends/mpd/serializer_test.py
View File

@ -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')]

62
tests/frontends/mpd/status_test.py
View File

@ -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)

2
tests/frontends/mpris/player_interface_test.py
View File

@ -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):

18
tests/help_test.py
View File

@ -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)

4
tests/models_test.py
View File

@ -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):

2
tests/utils/init_test.py
View File

@ -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')

17
tests/utils/settings_test.py
View File

@ -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',

6
tests/version_test.py
View File

@ -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())