Works on python 2/pypy

3 files changed, 36 insertions, 36 deletions

diff --git a/tests/models/album_test.py b/tests/models/album_test.py
index 680a5cb..5153626 100644
--- a/tests/models/album_test.py
+++ b/tests/models/album_test.py
@@ -2,20 +2,20 @@ from models.album import Album
 
 
 def test_instance(database):
-    album = Album(id=1, db=database)
+    album = Album(database, 1)
     assert album.id == 1
     assert album.name == "Album 1"
     assert album.date == "1999-02-04"
 
 
 def test_artists(database):
-    album = Album(id=1, db=database)
+    album = Album(database, 1)
     assert len(album.artists) == 1
     assert album.artists[0].name == "Artist 2"
 
 
 def test_tracks(database):
-    album = Album(id=1, db=database)
+    album = Album(database, 1)
     assert len(album.tracks) == 2
     assert album.tracks[0].name == "Album track 1"
     assert album.tracks[0].tracknumber == 1
@@ -36,28 +36,28 @@ def test_delete(database):
         album_id = cursor.lastrowid
         cursor.close()
 
-        album = Album(album_id, db=database)
+        album = Album(database, album_id)
 
         assert album.delete()
 
-    test_album = Album(album_id, db=database)
+    test_album = Album(database, album_id)
     assert not hasattr(test_album, "name")
 
 
 def test_search(database):
     search_payload = {"name": {"data": "Album 1", "operator": "="}}
-    album_results = Album.search(db=database, **search_payload)
+    album_results = Album.search(database, **search_payload)
 
     assert len(album_results) > 0
 
     invalid_search_payload = {"name": {"data": "This album does not exist",
                                        "operator": "="}}
-    no_album_results = Album.search(db=database, **invalid_search_payload)
+    no_album_results = Album.search(database, **invalid_search_payload)
 
     assert len(no_album_results) == 0
 
 
 def test_all(database):
-    album_results = Album.all(db=database)
+    album_results = Album.all(database)
 
     assert len(album_results) > 0
diff --git a/tests/models/artist_test.py b/tests/models/artist_test.py
index bb66813..b3504a1 100644
--- a/tests/models/artist_test.py
+++ b/tests/models/artist_test.py
@@ -2,27 +2,27 @@ from models.artist import Artist
 
 
 def test_instance(database):
-    album = Artist(id=1, db=database)
+    album = Artist(database, 1)
     assert album.id == 1
     assert album.name == "Artist 1"
 
 
 def test_albums(database):
-    artist1 = Artist(id=1, db=database)
+    artist1 = Artist(database, 1)
     assert len(artist1.albums) == 0
-    artist2 = Artist(id=2, db=database)
+    artist2 = Artist(database, 2)
     assert len(artist2.albums) == 1
     assert artist2.albums[0].name == "Album 1"
     assert artist2.albums[0].date == "1999-02-04"
 
 
 def test_tracks(database):
-    artist1 = Artist(id=1, db=database)
+    artist1 = Artist(database, 1)
     assert len(artist1.tracks) == 1
     assert artist1.tracks[0].name == "Non album track"
     assert artist1.tracks[0].tracknumber is None
     assert artist1.tracks[0].filename == "1.mp3"
-    artist2 = Artist(id=2, db=database)
+    artist2 = Artist(database, 2)
     assert artist2.tracks[0].name == "Album track 1"
     assert artist2.tracks[0].tracknumber == 1
     assert artist2.tracks[0].filename == "album/1.mp3"
@@ -40,28 +40,28 @@ def test_delete(database):
 
         artist_id = cursor.lastrowid
 
-        artist = Artist(artist_id, db=database)
+        artist = Artist(database, artist_id)
 
         assert artist.delete()
 
-    test_artist = Artist(artist_id, db=database)
+    test_artist = Artist(database, artist_id)
     assert not hasattr(test_artist, "name")
 
 
 def test_search(database):
     search_payload = {"name": {"data": "Artist 1", "operator": "="}}
-    artist_results = Artist.search(db=database, **search_payload)
+    artist_results = Artist.search(database, **search_payload)
 
     assert len(artist_results) > 0
 
     invalid_search_payload = {"name": {"data": "This artist does not exist",
                                        "operator": "="}}
-    no_artist_results = Artist.search(db=database, **invalid_search_payload)
+    no_artist_results = Artist.search(database, **invalid_search_payload)
 
     assert len(no_artist_results) == 0
 
 
 def test_all(database):
-    artist_results = Artist.all(db=database)
+    artist_results = Artist.all(database)
 
     assert len(artist_results) > 0
diff --git a/tests/models/track_test.py b/tests/models/track_test.py
index 56685fd..2bb4df1 100644
--- a/tests/models/track_test.py
+++ b/tests/models/track_test.py
@@ -4,14 +4,14 @@ from models.track import Track
 
 
 def test_instance(database):
-    track = Track(id=1, db=database)
+    track = Track(database, 1)
     assert track.id == 1
     assert track.name == "Non album track"
     assert track.filename == "1.mp3"
-
+    assert track.artists
 
 def test_as_dict(database):
-    track = Track(id=1, db=database)
+    track = Track(database, 1)
 
     track_dict = track.as_dict()
 
@@ -22,35 +22,35 @@ def test_as_dict(database):
 
 
 def test_album(database):
-    track1 = Track(id=1, db=database)
+    track1 = Track(database, 1)
     assert track1.album is None
-    track2 = Track(id=2, db=database)
+    track2 = Track(database, 2)
     assert track2.album.name == "Album 1"
     assert track2.album.date == "1999-02-04"
 
 
 def test_artists(database):
-    track = Track(id=1, db=database)
-    assert track.artists is not None
-    assert len(track.artists) > 0
+    track = Track(database, 1)
+    assert track.artists
     assert track.artists[0].name == "Artist 1"
 
 
 def test_find_by_path(database):
-    track1 = Track.find_by_path("album/2.mp3", db=database)
+    track1 = Track.find_by_path("album/2.mp3", database)
 
     assert track1.filename == "album/2.mp3"
     assert track1.name == "Album track 2"
     assert track1.grouping == "swing"
+    assert track1.artists
 
     nonexistent_track = Track.find_by_path("path/does/not/exist.mp3",
-                                           db=database)
+                                           database)
     assert nonexistent_track is None
 
 
 def test_search(database):
-    tracks = Track.search(db=database, name={"data": "Album track %",
-                                             "operator": "LIKE"})
+    tracks = Track.search(database, name={"data": "Album track %",
+                                          "operator": "LIKE"})
 
     assert tracks is not None
     assert len(tracks) == 2
@@ -59,7 +59,7 @@ def test_search(database):
 def test_store(database, test_file):
     metadata = mutagen.File(test_file, easy=True)
 
-    test_track = Track.store(test_file, metadata, db=database)
+    test_track = Track.store(test_file, metadata, database)
 
     assert test_track.filename == test_file
     assert test_track.name == "Silence"
@@ -76,7 +76,7 @@ def test_store(database, test_file):
 def test_update(database, test_file):
     metadata = {"artist": ["New artist"], "title": ["New title"]}
 
-    test_track = Track.find_by_path(test_file, db=database)
+    test_track = Track.find_by_path(test_file, database)
     test_track.update(metadata)
 
     assert test_track.artists
@@ -86,21 +86,21 @@ def test_update(database, test_file):
 
 
 def test_save(database, test_file):
-    test_track = Track.find_by_path(test_file, db=database)
+    test_track = Track.find_by_path(test_file, database)
 
     test_track.name = "Totally new name"
     test_track.save()
 
-    new_track_to_test = Track.find_by_path(test_file, db=database)
+    new_track_to_test = Track.find_by_path(test_file, database)
 
     assert new_track_to_test.name == "Totally new name"
 
 
 def test_delete(database, test_file):
-    test_track = Track.find_by_path(test_file, db=database)
+    test_track = Track.find_by_path(test_file, database)
 
     test_track.delete()
 
-    should_not_exist = Track.find_by_path(test_file, db=database)
+    should_not_exist = Track.find_by_path(test_file, database)
 
     assert should_not_exist is None