def test__add_artist_genres__multiple_albums_multiple_genres(self):
mock_artist_1 = mock_artist(spotify_id="mock-artist-id-1")
mock_artist_2 = mock_artist(spotify_id="mock-artist-id-2")
mock_album_1 = mock_album(genres=[],
artists=[mock_artist_1],
spotify_id="mock-album-id-1")
mock_album_2 = mock_album(genres=[],
artists=[mock_artist_2],
spotify_id="mock-album-id-2")
mock_albums = [mock_album_1, mock_album_2]
def mock_get_artist_genres(artist):
if artist == mock_artist_1:
return ["jazz"]
elif artist == mock_artist_2:
return ["rock", "prog rock"]
raise ValueError("unexpected artist ID")
self.mock_spotify.get_artist_genres = MagicMock(
side_effect=mock_get_artist_genres)
albums_with_genres = self.music_util._add_artist_genres(mock_albums)
self.assertEqual(albums_with_genres[mock_album_1].genres, ["jazz"])
self.assertEqual(sorted(albums_with_genres[mock_album_2].genres),
["prog rock", "rock"])
def test__detect_genre_matches__no_matches(self):
mock_albums = {
'id1': mock_album(spotify_id='id1', genres=['hip hop']),
'id2': mock_album(spotify_id='id2', genres=['rock'])
}
albums_by_genre = self.music_util._detect_genre_matches(mock_albums)
self.assertEqual(0, len(albums_by_genre.keys()))
def test_get_num_diff_artists__diff_ids__counts_both(self):
albums = [
mock_album(artists=[mock_artist(spotify_id="123")]),
mock_album(artists=[mock_artist(spotify_id="456")]),
]
num = self.music_util.get_num_diff_artists(albums)
self.assertEqual(2, num)
def test_filter_out_if_not_in_albums__all_tracks_in_albums__does_not_filter_any(
self):
mock_tracks = [mock_track(album=mock_album(spotify_id="album123"))]
mock_albums = [mock_album(spotify_id="album123")]
tracks = self.music_util.filter_out_if_not_in_albums(
mock_tracks, mock_albums)
self.assertEqual(tracks, mock_tracks)
def test_detect_genre_matches__no_matches__empty(self):
albums_by_id = {
"123": mock_album(spotify_id="123", genres=["A"]),
"456": mock_album(spotify_id="456", genres=["B"]),
}
matches = self.music_lib_api.detect_genre_matches(albums_by_id)
self.assertEqual(0, len(matches.keys()))
def test_get_num_diff_artists__duplicate__counts_once(self):
albums = [
mock_album(artists=[mock_artist(spotify_id="123")]),
mock_album(artists=[mock_artist(spotify_id="123")]),
]
num = self.music_util.get_num_diff_artists(albums)
self.assertEqual(1, num)
def test_filter_out_duplicates__capitalization(self):
albums = [
mock_album(name="Porgy and Bess"),
mock_album(name="Porgy And Bess")
]
choose_arbitrary_album = lambda album1, album2: album1
albums = self.music_util.filter_out_duplicates(albums,
choose_arbitrary_album)
self.assertEqual(1, len(albums))
def test_get_albums_as_readable_list__multiple_albums(self):
artist = mock_artist(name="mock artist")
album1 = mock_album(artists=[artist], name="mock album 1")
album2 = mock_album(artists=[artist], name="mock album 2")
albums = [album1, album2]
albums_as_readable_str = self.music_util.get_albums_as_readable_list(
albums)
self.assertEqual(
"- mock album 1 by mock artist\n- mock album 2 by mock artist",
albums_as_readable_str)
def test_filter_out_if_not_in_albums__some_tracks_in_albums__filter_out_others(
self):
mock_tracks = [
mock_track(album=mock_album(spotify_id="album123")),
mock_track(album=mock_album(spotify_id="some other album")),
]
mock_albums = [mock_album(spotify_id="album123")]
tracks = self.music_util.filter_out_if_not_in_albums(
mock_tracks, mock_albums)
self.assertEqual(len(tracks), 1)
self.assertEqual(tracks[0].spotify_album_id, "album123")
def test__group_albums_by_genre(self):
albums_by_id = {
"123": mock_album(spotify_id="123", genres=['jazz']),
"456": mock_album(spotify_id="456", genres=['jazz']),
}
album_groups = _group_albums(albums_by_id)
self.assertEqual(1, len(album_groups))
self.assertEqual(2, len(album_groups[0]))
album_ids = [album.spotify_id for album in album_groups[0]]
self.assertIn("123", album_ids)
self.assertIn("456", album_ids)
def test_detect_genre_matches__some_matches__only_returns_entries_for_albums_w_matches(
self):
albums_by_id = {
"123": mock_album(spotify_id="123", genres=["A"]),
"456": mock_album(spotify_id="456", genres=["A"]),
"789": mock_album(spotify_id="789", genres=["B"]),
}
matches = self.music_lib_api.detect_genre_matches(albums_by_id)
self.assertEqual(2, len(matches.keys()))
self.assertIn("123", matches)
self.assertIn("456", matches)
def test_group_albums_by_genre__same_genre_key__groups_together(self, _):
albums = [
mock_album(name="jiggery pokery"),
mock_album(name="mischief")
]
albums_by_genre = self.music_lib_api.group_albums_by_genre(albums)
self.assertEqual(["unbelievable-funk"], list(albums_by_genre.keys()))
self.assertEqual(2, len(albums_by_genre["unbelievable-funk"]))
album_names = [a['name'] for a in albums_by_genre["unbelievable-funk"]]
self.assertIn("jiggery pokery", album_names)
self.assertIn("mischief", album_names)
def test_is_live__ignores_word_in_title(self):
# Example 1
album = mock_album(name="LONG.LIVE.A$AP")
is_live = self.music_util.is_live(album)
self.assertFalse(is_live)
# Example 2
album = mock_album(name="Live Through This")
is_live = self.music_util.is_live(album)
self.assertFalse(is_live)
def test_is_a_demo__ignores_partial_word_match(self):
album = mock_album(
name="Sin Miedo (del Amory Otros Demonios) ∞ [Deluxe Version]")
is_demo = self.music_util.is_a_demo(album)
self.assertFalse(is_demo)
def test_is_a_demo__basic_scenario__matches(self):
album = mock_album(
name="The Witmark Demos: 1962-1964 (The Bootleg Series Vol. 9)")
is_demo = self.music_util.is_a_demo(album)
self.assertTrue(is_demo)
def test_is_live__in_parentheses__matches(self):
album = mock_album(
name=
"An Evening With Herbie Hancock & Chick Corea In Concert (Live)")
is_live = self.music_util.is_live(album)
self.assertTrue(is_live)
def test_filter_out_if_not_in_albums__no_tracks__none_returned(self):
mock_tracks = []
mock_albums = [mock_album(spotify_id="album123")]
tracks = self.music_util.filter_out_if_not_in_albums(
mock_tracks, mock_albums)
self.assertEqual(len(tracks), 0)
def test_is_a_bootleg__basic_scenario__matches(self):
album = mock_album(
name=
"The Bootleg Series Volumes 1-3 (Rare and Unreleased) 1961-1991")
is_bootleg = self.music_util.is_a_bootleg(album)
self.assertTrue(is_bootleg)
def test__detect_genre_matches__2_albums_1_genre(self):
mock_album1 = mock_album(spotify_id='id1', genres=['hip hop'])
mock_album2 = mock_album(spotify_id='id2', genres=['hip hop'])
mock_albums = {
mock_album1: mock_album(spotify_id='id1', genres=['hip hop']),
mock_album2: mock_album(spotify_id='id2', genres=['hip hop'])
}
genre_matches = self.music_util._detect_genre_matches(mock_albums)
self.assertEqual(mock_albums.keys(), genre_matches.keys())
self.assertIn(mock_album1, genre_matches)
self.assertIn(mock_album2, genre_matches)
self.assertIn(mock_album2, genre_matches[mock_album1])
self.assertIn(mock_album1, genre_matches[mock_album2])
self.assertEqual(['hip hop'], genre_matches[mock_album1][mock_album2])
self.assertEqual(['hip hop'], genre_matches[mock_album2][mock_album1])
def test_detect_genre_matches__two_albums__match_counts_are_symmetrical(
self):
albums_by_id = {
"123": mock_album(spotify_id="123", genres=["A", "B", "C"]),
"456": mock_album(spotify_id="456", genres=["A", "B", "D"]),
}
matches = self.music_lib_api.detect_genre_matches(albums_by_id)
self.assertEqual(2, len(matches.keys()))
self.assertIn("123", matches)
self.assertIn("456", matches)
self.assertEqual(1, len(matches["123"]))
self.assertEqual(1, len(matches["456"]))
self.assertEqual(2, len(matches["123"]["456"]))
self.assertEqual(2, len(matches["456"]["123"]))
self.assertEqual(["A", "B"], matches["123"]["456"])
self.assertEqual(["A", "B"], matches["456"]["123"])
def test_is_live__in_brackets__matches(self):
album = mock_album(
name=
"Miles in Montreux (feat. Rich Margitza, Adam Holzman, Benny Rietveld) [Live]"
)
is_live = self.music_util.is_live(album)
self.assertTrue(is_live)
def test_get_albums_as_readable_list__one_album(self):
artist = mock_artist(name="mock artist")
album = mock_album(artists=[artist], name="mock album")
albums = [album]
albums_as_readable_str = self.music_util.get_albums_as_readable_list(
albums)
self.assertEqual("- mock album by mock artist", albums_as_readable_str)
def test_group_albums_by_genre__diff_genre_key__groups_separately(self, _):
albums = [
mock_album(name="jiggery pokery"),
mock_album(name="mischief")
]
albums_by_genre = self.music_lib_api.group_albums_by_genre(albums)
self.assertEqual(2, len(albums_by_genre.keys()),
"Expected two separate groups of albums")
self.assertIn("unbelievable-funk", albums_by_genre)
self.assertIn("ambient-whispering", albums_by_genre)
self.assertEqual(1, len(albums_by_genre["unbelievable-funk"]))
self.assertEqual(1, len(albums_by_genre["ambient-whispering"]))
album_names = [a['name'] for a in albums_by_genre["unbelievable-funk"]]
self.assertEqual("jiggery pokery",
albums_by_genre["unbelievable-funk"][0]['name'])
self.assertEqual("mischief",
albums_by_genre["ambient-whispering"][0]['name'])
def test__group_albums__2_albums_2_genre(self):
mock_album1 = mock_album(spotify_id='id1')
mock_album2 = mock_album(spotify_id='id2')
albums = [mock_album1, mock_album2]
genre_matches = {
mock_album1: {
mock_album2: ['rap', 'hip hop']
},
mock_album2: {
mock_album1: ['rap', 'hip hop']
},
}
album_groups = self.music_util._group_albums(albums, genre_matches)
self.assertEqual(1, len(album_groups))
self.assertEqual({mock_album1, mock_album2}, album_groups[0]['albums'])
self.assertEqual(sorted(['rap', 'hip hop']),
sorted(album_groups[0]['genres']))
def test_get_albums_as_readable_list__multiple_artists(self):
artist1, artist2 = mock_artist(name="mock artist 1"), mock_artist(
name="mock artist 2")
album = mock_album(artists=[artist1, artist2], name="mock album")
albums = [album]
albums_as_readable_str = self.music_util.get_albums_as_readable_list(
albums)
self.assertEqual("- mock album by mock artist 1, mock artist 2",
albums_as_readable_str)
def test__add_artist_genres__single_album_single_genre(self):
self.mock_spotify.get_artist_genres = MagicMock(return_value=["jazz"])
mock_album1 = mock_album(
genres=[],
artists=[mock_artist(spotify_id="mock-artist-id")],
spotify_id="mock-album-id")
mock_albums = [mock_album1]
albums_with_genres = self.music_util._add_artist_genres(mock_albums)
self.assertEqual(albums_with_genres[mock_album1].genres, ["jazz"])
def test_group_albums_by_genre__single_album(self, _):
albums_by_genre = self.music_lib_api.group_albums_by_genre(
[mock_album(name="jiggery pokery")])
self.assertEqual(1, len(albums_by_genre.keys()),
"Expected 1 group of albums")
self.assertIn("unbelievable-funk", albums_by_genre)
self.assertEqual(1, len(albums_by_genre["unbelievable-funk"]))
self.assertEqual(
"jiggery pokery",
albums_by_genre["unbelievable-funk"][0]["name"],
)
def test__group_albums__2_albums_1_genre(self):
mock_album1 = mock_album(spotify_id='id1')
mock_album2 = mock_album(spotify_id='id2')
albums = [mock_album1, mock_album2]
genre_matches = {
mock_album1: {
mock_album2: ['rap']
},
mock_album2: {
mock_album1: ['rap']
},
}
album_groups = self.music_util._group_albums(albums, genre_matches)
self.assertEqual(
[{
'albums': {mock_album1, mock_album2},
'genres': ['rap']
}],
album_groups,
)
def test__detect_genre_matches__3_albums_3_genres(self):
mock_album1 = mock_album(spotify_id='id1',
genres=['hip hop', 'rap', 'trap'])
mock_album2 = mock_album(spotify_id='id2',
genres=['hip hop', 'rap', 'trap'])
mock_album3 = mock_album(spotify_id='id3',
genres=['hip hop', 'rap', 'trap'])
mock_albums = {
mock_album1: mock_album1,
mock_album2: mock_album2,
mock_album3: mock_album3,
}
genre_matches = self.music_util._detect_genre_matches(mock_albums)
self.assertEqual(mock_albums.keys(), genre_matches.keys())
self.assertIn(mock_album1, genre_matches)
self.assertIn(mock_album2, genre_matches)
self.assertIn(mock_album3, genre_matches)
self.assertIn(mock_album2, genre_matches[mock_album1])
self.assertIn(mock_album3, genre_matches[mock_album1])
self.assertIn(mock_album1, genre_matches[mock_album2])
self.assertIn(mock_album3, genre_matches[mock_album2])
self.assertIn(mock_album1, genre_matches[mock_album3])
self.assertIn(mock_album2, genre_matches[mock_album3])
self.assertEqual(['hip hop', 'rap', 'trap'],
genre_matches[mock_album1][mock_album2])
self.assertEqual(['hip hop', 'rap', 'trap'],
genre_matches[mock_album1][mock_album3])
self.assertEqual(['hip hop', 'rap', 'trap'],
genre_matches[mock_album2][mock_album1])
self.assertEqual(['hip hop', 'rap', 'trap'],
genre_matches[mock_album2][mock_album3])
self.assertEqual(['hip hop', 'rap', 'trap'],
genre_matches[mock_album3][mock_album1])
self.assertEqual(['hip hop', 'rap', 'trap'],
genre_matches[mock_album3][mock_album2])
def test_detect_genre_matches__transitive_match__ignored(self):
albums_by_id = {
"123": mock_album(spotify_id="123", genres=["A", "B"]),
"456": mock_album(spotify_id="456", genres=["B", "C"]),
"789": mock_album(spotify_id="789", genres=["C", "D"]),
}
matches = self.music_lib_api.detect_genre_matches(albums_by_id)
self.assertEqual(3, len(matches.keys()))
self.assertIn("123", matches)
self.assertIn("456", matches)
self.assertIn("789", matches)
self.assertEqual(1, len(matches["123"]))
self.assertEqual(2, len(matches["456"]))
self.assertEqual(1, len(matches["789"]))
self.assertEqual(1, len(matches["123"]["456"]))
self.assertEqual(1, len(matches["456"]["123"]))
self.assertEqual(1, len(matches["456"]["789"]))
self.assertEqual(1, len(matches["789"]["456"]))
self.assertEqual(["B"], matches["123"]["456"])
self.assertEqual(["B"], matches["456"]["123"])
self.assertEqual(["C"], matches["456"]["789"])
self.assertEqual(["C"], matches["789"]["456"])
