def test_parse_album_or_comp(multitracks):
html, expected_release = multitracks
guru = Metaguru(html, expected_release.media)
include_all = False
actual_album = guru.album(include_all)
disctitle = actual_album.tracks[0].disctitle
assert disctitle == expected_release.disctitle
expected_album = expected_release.albuminfo
assert hasattr(actual_album, "tracks")
assert len(actual_album.tracks) == expected_release.track_count
expected_album.tracks.sort(key=lambda t: t.index)
actual_album.tracks.sort(key=lambda t: t.index)
for actual_track, expected_track in zip(actual_album.tracks,
expected_album.tracks):
check(actual_track, expected_track)
actual_album.tracks = None
expected_album.tracks = None
check(actual_album, expected_album)
def test_parse_release_date(string, expected):
assert Metaguru.parse_release_date(string) == expected
def test_mediums_count(name, expected):
assert Metaguru.get_vinyl_count(name) == expected
def test_description(meta, expected):
meta.update(datePublished="doesntmatter")
guru = Metaguru(json.dumps(meta), media="Vinyl")
guru._media = meta.get("albumRelease", [{}])[0]
assert guru.description == expected, vars(guru)
def test_parse_single_track_release(single_track_release):
html, expected = single_track_release
guru = Metaguru(html)
check(guru.singleton, expected.singleton)
def test_clean_up_album_name(album, extras, expected):
assert Metaguru.clean_up_album_name(album, *extras) == expected
def test_parse_catalognum(description, album, expected):
assert Metaguru.parse_catalognum(album, "", description) == expected
def test_parse_country(name, expected):
guru = Metaguru("")
guru.meta = {"publisher": {"foundingLocation": {"name": name}}}
assert guru.country == expected
def test_check_digital_only(name, expected_digital_only, expected_name):
expected = dict(digital_only=expected_digital_only)
if expected_name:
expected.update(name=expected_name)
assert Metaguru.check_digital_only(name) == expected
def test_parse_track_name(name, expected):
parts = ("track_alt", "artist", "title")
assert Metaguru.parse_track_name(name) == dict(zip(parts, expected))