models: Use with stmts in exception tests

tests/test_models.py

@@ -49,8 +49,8 @@ class GenericCopyTest(unittest.TestCase):
         self.assertIn(artist2, copy.artists)
 
     def test_copying_track_with_invalid_key(self):
-        test = lambda: Track().copy(invalid_key=True)
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            Track().copy(invalid_key=True)
 
     def test_copying_track_to_remove(self):
         track = Track(name='foo').copy(name=None)
@@ -62,17 +62,19 @@ class RefTest(unittest.TestCase):
         uri = 'an_uri'
         ref = Ref(uri=uri)
         self.assertEqual(ref.uri, uri)
-        self.assertRaises(AttributeError, setattr, ref, 'uri', None)
+        with self.assertRaises(AttributeError):
+            ref.uri = None
 
     def test_name(self):
         name = 'a name'
         ref = Ref(name=name)
         self.assertEqual(ref.name, name)
-        self.assertRaises(AttributeError, setattr, ref, 'name', None)
+        with self.assertRaises(AttributeError):
+            ref.name = None
 
     def test_invalid_kwarg(self):
-        test = lambda: SearchResult(foo='baz')
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            SearchResult(foo='baz')
 
     def test_repr_without_results(self):
         self.assertEquals(
@@ -133,31 +135,33 @@ class ArtistTest(unittest.TestCase):
         uri = 'an_uri'
         artist = Artist(uri=uri)
         self.assertEqual(artist.uri, uri)
-        self.assertRaises(AttributeError, setattr, artist, 'uri', None)
+        with self.assertRaises(AttributeError):
+            artist.uri = None
 
     def test_name(self):
         name = 'a name'
         artist = Artist(name=name)
         self.assertEqual(artist.name, name)
-        self.assertRaises(AttributeError, setattr, artist, 'name', None)
+        with self.assertRaises(AttributeError):
+            artist.name = None
 
     def test_musicbrainz_id(self):
         mb_id = 'mb-id'
         artist = Artist(musicbrainz_id=mb_id)
         self.assertEqual(artist.musicbrainz_id, mb_id)
-        self.assertRaises(
-            AttributeError, setattr, artist, 'musicbrainz_id', None)
+        with self.assertRaises(AttributeError):
+            artist.musicbrainz_id = None
 
     def test_invalid_kwarg(self):
-        test = lambda: Artist(foo='baz')
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            Artist(foo='baz')
 
     def test_invalid_kwarg_with_name_matching_method(self):
-        test = lambda: Artist(copy='baz')
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            Artist(copy='baz')
 
-        test = lambda: Artist(serialize='baz')
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            Artist(serialize='baz')
 
     def test_repr(self):
         self.assertEquals(
@@ -184,22 +188,22 @@ class ArtistTest(unittest.TestCase):
         artist = Artist(uri='uri', name='name').serialize()
         artist['foo'] = 'foo'
         serialized = json.dumps(artist)
-        test = lambda: json.loads(serialized, object_hook=model_json_decoder)
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            json.loads(serialized, object_hook=model_json_decoder)
 
     def test_to_json_and_back_with_field_matching_method(self):
         artist = Artist(uri='uri', name='name').serialize()
         artist['copy'] = 'foo'
         serialized = json.dumps(artist)
-        test = lambda: json.loads(serialized, object_hook=model_json_decoder)
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            json.loads(serialized, object_hook=model_json_decoder)
 
     def test_to_json_and_back_with_field_matching_internal_field(self):
         artist = Artist(uri='uri', name='name').serialize()
         artist['__mro__'] = 'foo'
         serialized = json.dumps(artist)
-        test = lambda: json.loads(serialized, object_hook=model_json_decoder)
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            json.loads(serialized, object_hook=model_json_decoder)
 
     def test_eq_name(self):
         artist1 = Artist(name='name')
@@ -261,19 +265,22 @@ class AlbumTest(unittest.TestCase):
         uri = 'an_uri'
         album = Album(uri=uri)
         self.assertEqual(album.uri, uri)
-        self.assertRaises(AttributeError, setattr, album, 'uri', None)
+        with self.assertRaises(AttributeError):
+            album.uri = None
 
     def test_name(self):
         name = 'a name'
         album = Album(name=name)
         self.assertEqual(album.name, name)
-        self.assertRaises(AttributeError, setattr, album, 'name', None)
+        with self.assertRaises(AttributeError):
+            album.name = None
 
     def test_artists(self):
         artist = Artist()
         album = Album(artists=[artist])
         self.assertIn(artist, album.artists)
-        self.assertRaises(AttributeError, setattr, album, 'artists', None)
+        with self.assertRaises(AttributeError):
+            album.artists = None
 
     def test_artists_none(self):
         self.assertEqual(set(), Album(artists=None).artists)
@@ -282,39 +289,43 @@ class AlbumTest(unittest.TestCase):
         num_tracks = 11
         album = Album(num_tracks=num_tracks)
         self.assertEqual(album.num_tracks, num_tracks)
-        self.assertRaises(AttributeError, setattr, album, 'num_tracks', None)
+        with self.assertRaises(AttributeError):
+            album.num_tracks = None
 
     def test_num_discs(self):
         num_discs = 2
         album = Album(num_discs=num_discs)
         self.assertEqual(album.num_discs, num_discs)
-        self.assertRaises(AttributeError, setattr, album, 'num_discs', None)
+        with self.assertRaises(AttributeError):
+            album.num_discs = None
 
     def test_date(self):
         date = '1977-01-01'
         album = Album(date=date)
         self.assertEqual(album.date, date)
-        self.assertRaises(AttributeError, setattr, album, 'date', None)
+        with self.assertRaises(AttributeError):
+            album.date = None
 
     def test_musicbrainz_id(self):
         mb_id = 'mb-id'
         album = Album(musicbrainz_id=mb_id)
         self.assertEqual(album.musicbrainz_id, mb_id)
-        self.assertRaises(
-            AttributeError, setattr, album, 'musicbrainz_id', None)
+        with self.assertRaises(AttributeError):
+            album.musicbrainz_id = None
 
     def test_images(self):
         image = 'data:foobar'
         album = Album(images=[image])
         self.assertIn(image, album.images)
-        self.assertRaises(AttributeError, setattr, album, 'images', None)
+        with self.assertRaises(AttributeError):
+            album.images = None
 
     def test_images_none(self):
         self.assertEqual(set(), Album(images=None).images)
 
     def test_invalid_kwarg(self):
-        test = lambda: Album(foo='baz')
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            Album(foo='baz')
 
     def test_repr_without_artists(self):
         self.assertEquals(
@@ -466,19 +477,22 @@ class TrackTest(unittest.TestCase):
         uri = 'an_uri'
         track = Track(uri=uri)
         self.assertEqual(track.uri, uri)
-        self.assertRaises(AttributeError, setattr, track, 'uri', None)
+        with self.assertRaises(AttributeError):
+            track.uri = None
 
     def test_name(self):
         name = 'a name'
         track = Track(name=name)
         self.assertEqual(track.name, name)
-        self.assertRaises(AttributeError, setattr, track, 'name', None)
+        with self.assertRaises(AttributeError):
+            track.name = None
 
     def test_artists(self):
         artists = [Artist(name='name1'), Artist(name='name2')]
         track = Track(artists=artists)
         self.assertEqual(set(track.artists), set(artists))
-        self.assertRaises(AttributeError, setattr, track, 'artists', None)
+        with self.assertRaises(AttributeError):
+            track.artists = None
 
     def test_artists_none(self):
         self.assertEqual(set(), Track(artists=None).artists)
@@ -487,7 +501,8 @@ class TrackTest(unittest.TestCase):
         artists = [Artist(name='name1'), Artist(name='name2')]
         track = Track(composers=artists)
         self.assertEqual(set(track.composers), set(artists))
-        self.assertRaises(AttributeError, setattr, track, 'composers', None)
+        with self.assertRaises(AttributeError):
+            track.composers = None
 
     def test_composers_none(self):
         self.assertEqual(set(), Track(composers=None).composers)
@@ -496,7 +511,8 @@ class TrackTest(unittest.TestCase):
         artists = [Artist(name='name1'), Artist(name='name2')]
         track = Track(performers=artists)
         self.assertEqual(set(track.performers), set(artists))
-        self.assertRaises(AttributeError, setattr, track, 'performers', None)
+        with self.assertRaises(AttributeError):
+            track.performers = None
 
     def test_performers_none(self):
         self.assertEqual(set(), Track(performers=None).performers)
@@ -505,48 +521,54 @@ class TrackTest(unittest.TestCase):
         album = Album()
         track = Track(album=album)
         self.assertEqual(track.album, album)
-        self.assertRaises(AttributeError, setattr, track, 'album', None)
+        with self.assertRaises(AttributeError):
+            track.album = None
 
     def test_track_no(self):
         track_no = 7
         track = Track(track_no=track_no)
         self.assertEqual(track.track_no, track_no)
-        self.assertRaises(AttributeError, setattr, track, 'track_no', None)
+        with self.assertRaises(AttributeError):
+            track.track_no = None
 
     def test_disc_no(self):
         disc_no = 2
         track = Track(disc_no=disc_no)
         self.assertEqual(track.disc_no, disc_no)
-        self.assertRaises(AttributeError, setattr, track, 'disc_no', None)
+        with self.assertRaises(AttributeError):
+            track.disc_no = None
 
     def test_date(self):
         date = '1977-01-01'
         track = Track(date=date)
         self.assertEqual(track.date, date)
-        self.assertRaises(AttributeError, setattr, track, 'date', None)
+        with self.assertRaises(AttributeError):
+            track.date = None
 
     def test_length(self):
         length = 137000
         track = Track(length=length)
         self.assertEqual(track.length, length)
-        self.assertRaises(AttributeError, setattr, track, 'length', None)
+        with self.assertRaises(AttributeError):
+            track.length = None
 
     def test_bitrate(self):
         bitrate = 160
         track = Track(bitrate=bitrate)
         self.assertEqual(track.bitrate, bitrate)
-        self.assertRaises(AttributeError, setattr, track, 'bitrate', None)
+        with self.assertRaises(AttributeError):
+            track.bitrate = None
 
     def test_musicbrainz_id(self):
         mb_id = 'mb-id'
         track = Track(musicbrainz_id=mb_id)
         self.assertEqual(track.musicbrainz_id, mb_id)
-        self.assertRaises(
-            AttributeError, setattr, track, 'musicbrainz_id', None)
+        with self.assertRaises(AttributeError):
+            track.musicbrainz_id = None
 
     def test_invalid_kwarg(self):
-        test = lambda: Track(foo='baz')
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            Track(foo='baz')
 
     def test_repr_without_artists(self):
         self.assertEquals(
@@ -753,17 +775,19 @@ class TlTrackTest(unittest.TestCase):
         tlid = 123
         tl_track = TlTrack(tlid=tlid)
         self.assertEqual(tl_track.tlid, tlid)
-        self.assertRaises(AttributeError, setattr, tl_track, 'tlid', None)
+        with self.assertRaises(AttributeError):
+            tl_track.tlid = None
 
     def test_track(self):
         track = Track()
         tl_track = TlTrack(track=track)
         self.assertEqual(tl_track.track, track)
-        self.assertRaises(AttributeError, setattr, tl_track, 'track', None)
+        with self.assertRaises(AttributeError):
+            tl_track.track = None
 
     def test_invalid_kwarg(self):
-        test = lambda: TlTrack(foo='baz')
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            TlTrack(foo='baz')
 
     def test_positional_args(self):
         tlid = 123
@@ -829,19 +853,22 @@ class PlaylistTest(unittest.TestCase):
         uri = 'an_uri'
         playlist = Playlist(uri=uri)
         self.assertEqual(playlist.uri, uri)
-        self.assertRaises(AttributeError, setattr, playlist, 'uri', None)
+        with self.assertRaises(AttributeError):
+            playlist.uri = None
 
     def test_name(self):
         name = 'a name'
         playlist = Playlist(name=name)
         self.assertEqual(playlist.name, name)
-        self.assertRaises(AttributeError, setattr, playlist, 'name', None)
+        with self.assertRaises(AttributeError):
+            playlist.name = None
 
     def test_tracks(self):
         tracks = [Track(), Track(), Track()]
         playlist = Playlist(tracks=tracks)
         self.assertEqual(list(playlist.tracks), tracks)
-        self.assertRaises(AttributeError, setattr, playlist, 'tracks', None)
+        with self.assertRaises(AttributeError):
+            playlist.tracks = None
 
     def test_length(self):
         tracks = [Track(), Track(), Track()]
@@ -852,8 +879,8 @@ class PlaylistTest(unittest.TestCase):
         last_modified = 1390942873000
         playlist = Playlist(last_modified=last_modified)
         self.assertEqual(playlist.last_modified, last_modified)
-        self.assertRaises(
-            AttributeError, setattr, playlist, 'last_modified', None)
+        with self.assertRaises(AttributeError):
+            playlist.last_modified = None
 
     def test_with_new_uri(self):
         tracks = [Track()]
@@ -906,8 +933,8 @@ class PlaylistTest(unittest.TestCase):
         self.assertEqual(new_playlist.last_modified, new_last_modified)
 
     def test_invalid_kwarg(self):
-        test = lambda: Playlist(foo='baz')
-        self.assertRaises(TypeError, test)
+        with self.assertRaises(TypeError):
+            Playlist(foo='baz')
 
     def test_repr_without_tracks(self):
         self.assertEquals(
@@ -1017,25 +1044,29 @@ class SearchResultTest(unittest.TestCase):
         uri = 'an_uri'
         result = SearchResult(uri=uri)
         self.assertEqual(result.uri, uri)
-        self.assertRaises(AttributeError, setattr, result, 'uri', None)
+        with self.assertRaises(AttributeError):
+            result.uri = None
 
     def test_tracks(self):
         tracks = [Track(), Track(), Track()]
         result = SearchResult(tracks=tracks)
         self.assertEqual(list(result.tracks), tracks)
-        self.assertRaises(AttributeError, setattr, result, 'tracks', None)
+        with self.assertRaises(AttributeError):
+            result.tracks = None
 
     def test_artists(self):
         artists = [Artist(), Artist(), Artist()]
         result = SearchResult(artists=artists)
         self.assertEqual(list(result.artists), artists)
-        self.assertRaises(AttributeError, setattr, result, 'artists', None)
+        with self.assertRaises(AttributeError):
+            result.artists = None
 
     def test_albums(self):
         albums = [Album(), Album(), Album()]
         result = SearchResult(albums=albums)
         self.assertEqual(list(result.albums), albums)
-        self.assertRaises(AttributeError, setattr, result, 'albums', None)
+        with self.assertRaises(AttributeError):
+            result.albums = None
 
     def test_invalid_kwarg(self):
         test = lambda: SearchResult(foo='baz')