def test_defaults(s):
failUnlessEq = s.failUnlessEqual
song = Fakesong({})
album = Album(song)
failUnlessEq(album("foo", "x"), "x")
album.songs.add(song)
failUnlessEq(album("~#length", "x"), song("~#length", "x"))
failUnlessEq(album("~#bitrate", "x"), song("~#bitrate", "x"))
failUnlessEq(album("~#rating", "x"), song("~#rating", "x"))
failUnlessEq(album("~#playcount", "x"), song("~#playcount", "x"))
failUnlessEq(album("~#mtime", "x"), song("~#mtime", "x"))
failUnlessEq(album("~#year", "x"), song("~#year", "x"))
failUnlessEq(album("~#foo", "x"), song("~#foo", "x"))
failUnlessEq(album("foo", "x"), song("foo", "x"))
failUnlessEq(album("~foo", "x"), song("~foo", "x"))
failUnlessEq(album("~people", "x"), song("~people", "x"))
failUnlessEq(album("~peoplesort", "x"), song("~peoplesort", "x"))
failUnlessEq(album("~performer", "x"), song("~performer", "x"))
failUnlessEq(album("~performersort", "x"), song("~performersort", "x"))
failUnlessEq(album("~rating", "x"), song("~rating", "x"))
for p in PEOPLE:
failUnlessEq(album(p, "x"), song(p, "x"))
for p in NUMERIC_ZERO_DEFAULT:
failUnlessEq(album(p, "x"), song(p, "x"))
def test_internal_tags(s):
songs = [
Fakesong({
"~#length": 5,
"discnumber": "1",
"date": "2038"
}),
Fakesong({
"~#length": 7,
"dummy": "d\ne",
"discnumber": "2"
})
]
album = Album(songs[0])
album.songs = set(songs)
s.failIfEqual(album.comma("~long-length"), "")
s.failIfEqual(album.comma("~tracks"), "")
s.failIfEqual(album.comma("~discs"), "")
s.failUnlessEqual(album.comma("~foo"), "")
s.failUnlessEqual(album.comma(""), "")
s.failUnlessEqual(album.comma("~"), "")
s.failUnlessEqual(album.get("~#"), "")
def test_tied_num_tags(s):
songs = [
Fakesong({
"~#length": 5,
"title": "c",
"~#rating": 0.4
}),
Fakesong({
"~#length": 7,
"dummy": "d\ne",
"~#rating": 0.6
}),
Fakesong({
"~#length": 0,
"dummy2": 5,
"~#rating": 0.5
})
]
album = Album(songs[0])
album.songs = set(songs)
s.failUnlessEqual(album.comma("~foo~~s~~~"), "")
s.failUnlessEqual(album.comma("~#length~dummy"), "12 - d, e")
s.failUnlessEqual(album.comma("~#rating~dummy"), "0.50 - d, e")
s.failUnlessEqual(album.comma("~#length:sum~dummy"), "12 - d, e")
s.failUnlessEqual(album.comma("~#dummy2"), 5)
s.failUnlessEqual(album.comma("~#dummy3"), "")
def test_single_rating(s):
songs = [Fakesong({"~#rating": 0.75})]
album = Album(songs[0])
album.songs = set(songs)
# One song should average to its own rating
s.failUnlessEqual(album.get("~#rating:avg"), songs[0]("~#rating"))
# BAV should now be default for rating
s.failUnlessEqual(album.get("~#rating:bav"), album.get("~#rating:avg"))
def test_tied_tags(s):
songs = [
Fakesong({"artist": "a", "title": "c"}),
Fakesong({"artist": "a", "dummy": "d\ne"})
]
album = Album(songs[0])
album.songs = set(songs)
s.failUnlessEqual(album.comma("~artist~dummy"), "a - e, d")
def test_peoplesort_sort(s):
songs = [
Fakesong({"albumartistsort": "aa", "artist": "b\na"}),
Fakesong({"albumartist": "aa", "artistsort": "a\na"})
]
album = Album(songs[0])
album.songs = set(songs)
s.failUnlessEqual(album.comma("~peoplesort"), "aa, a, b")
def test_multiple_ratings(s):
r1, r2 = 1.0, 0.5
songs = [Fakesong({"~#rating": r1}), Fakesong({"~#rating": r2})]
album = Album(songs[0])
album.songs = set(songs)
# Standard averaging still available
s.failUnlessEqual(album("~#rating:avg"), avg([r1, r2]))
# C = 0.0 => emulate arithmetic mean
config.set("settings", "bayesian_rating_factor", 0.0)
s.failUnlessEqual(album("~#rating:bav"), album("~#rating:avg"))
def test_numeric_funcs_text(self):
songs = NUMERIC_SONGS
album = Album(songs[0])
album.songs = set(songs)
self.assertEqual(album("~length:sum"), "0:12")
self.assertEqual(album("~length:min"), "0:01")
self.assertEqual(album("~long-length:min"), "1 second")
self.assertEqual(album("~tracks:min"), "6 tracks")
self.assertEqual(album("~discs:min"), "2 discs")
self.assertEqual(album("~rating:min"), format_rating(0.1))
self.assertEqual(album("~filesize:min"), "0 B")
def test_bayesian_multiple_ratings(s):
# separated from above to avoid caching
c, r1, r2 = 5, 1.0, 0.5
songs = [Fakesong({"~#rating": r1}), Fakesong({"~#rating": r2})]
album = Album(songs[0])
album.songs = set(songs)
config.set("settings", "bayesian_rating_factor", float(c))
s.failUnlessEqual(
config.getfloat("settings", "bayesian_rating_factor"), float(c))
expected = avg(c * [config.RATINGS.default] + [r1, r2])
s.failUnlessEqual(album("~#rating:bav"), expected)
s.failUnlessEqual(album("~#rating"), expected)
def test_methods(s):
songs = [
Fakesong({"b": "bb4\nbb1\nbb1", "c": "cc1\ncc3\ncc3"}),
Fakesong({"b": "bb1\nbb1\nbb4", "c": "cc3\ncc1\ncc3"})
]
album = Album(songs[0])
album.songs = set(songs)
s.failUnlessEqual(album.list("c"), ["cc3", "cc1"])
s.failUnlessEqual(album.list("~c~b"), ["cc3", "cc1", "bb1", "bb4"])
s.failUnlessEqual(album.comma("c"), "cc3, cc1")
s.failUnlessEqual(album.comma("~c~b"), "cc3, cc1 - bb1, bb4")
def test_numeric_comma(self):
songs = [Fakesong({
"~#added": long(1),
"~#rating": 0.5,
"~#bitrate": 42,
"~#length": 1,
})]
album = Album(songs[0])
album.songs = set(songs)
self.assertEqual(album.comma("~#added"), 1)
self.assertEqual(album.comma("~#rating"), 0.5)
self.assertEqual(album.comma("~#bitrate"), 42)
def __add(self, items):
changed = set()
new = set()
for song in items:
key = song.album_key
if key in self._contents:
changed.add(self._contents[key])
else:
album = Album(song)
self._contents[key] = album
new.add(album)
self._contents[key].songs.add(song)
changed -= new
return changed, new
def test_numeric_ops(s):
songs = NUMERIC_SONGS
album = Album(songs[0])
album.songs = set(songs)
s.failUnlessEqual(album.get("~#length"), 12)
s.failUnlessEqual(album.get("~#length:sum"), 12)
s.failUnlessEqual(album.get("~#length:max"), 7)
s.failUnlessEqual(album.get("~#length:min"), 1)
s.failUnlessEqual(album.get("~#length:avg"), 4)
s.failUnlessEqual(album.get("~#length:foo"), 0)
s.failUnlessEqual(album.get("~#added"), 7)
s.failUnlessEqual(album.get("~#lastplayed"), 88)
s.failUnlessEqual(album.get("~#bitrate"), 200)
s.failUnlessEqual(album.get("~#year"), 33)
s.failUnlessEqual(album.get("~#rating"), 0.3)
s.failUnlessEqual(album.get("~#originalyear"), 2002)
from quodlibet import config, app
from quodlibet.browsers.albums import AlbumList
from quodlibet.formats import AudioFile
from quodlibet.util.collection import Album
from quodlibet.util.dprint import print_d
from tests import init_fake_app, destroy_fake_app
from tests.plugin import PluginTestCase
A1S1 = AudioFile(
{'album': 'greatness', 'title': 'excellent', 'artist': 'fooman',
'~#lastplayed': 1234, '~#rating': 0.75})
A1S2 = AudioFile(
{'album': 'greatness', 'title': 'superlative', 'artist': 'fooman',
'~#lastplayed': 1234, '~#rating': 1.0})
A1 = Album(A1S1)
A1.songs = {A1S1, A1S2}
A2S1 = AudioFile({'album': 'mediocrity', 'title': 'blah', 'artist': 'fooman',
'~#lastplayed': 1234})
A2S2 = AudioFile({'album': 'mediocrity', 'title': 'meh', 'artist': 'fooman',
'~#lastplayed': 1234})
A2 = Album(A2S1)
A2.songs = {A2S1, A2S2}
A3S1 = AudioFile(
{'album': 'disappointment', 'title': 'shameful', 'artist': 'poorman',
'~#lastplayed': 2345, '~#rating': 0.25})
A3S2 = AudioFile(
{'album': 'disappointment', 'title': 'zero', 'artist': 'poorman',
'~#lastplayed': 2345, '~#rating': 0.0})
def _get_album(self, dict_):
song = AudioFile(dict_)
album = Album(song)
album.songs.add(song)
return album
