def test_can_change(self): af = AudioFile() self.failIf(af.can_change("~foobar")) self.failIf(af.can_change("=foobar")) self.failIf(af.can_change("foo=bar")) self.failIf(af.can_change("")) self.failUnless(af.can_change("foo bar"))
def test_to_dump_unicode(self): b = AudioFile(bar_1_1) b[u"öäü"] = u"öäü" dump = b.to_dump() n = AudioFile() n.from_dump(dump) self.assertEqual(n[u"öäü"], u"öäü")
def test(self): lib = SongFileLibrary() with temp_filename() as song_fn: song = AudioFile({"~filename": song_fn}) song.sanitize() lib.add([song]) with temp_filename() as xml_fn: with open(xml_fn, "wb") as h: x = get_example_xml(song("~filename"), 1, 1371802107) h.write(x) handler = self.mod.RBDBContentHandler(lib) xml.sax.parse(xml_fn, handler) self.assertEqual(song("~#rating"), 0.2) self.assertEqual(song("~#lastplayed"), 1371802107) self.assertEqual(song("~#playcount"), 1) with open(xml_fn, "wb") as h: x = get_example_xml(song("~filename"), 2, 1371802107 - 1) h.write(x) handler = self.mod.RBDBContentHandler(lib) xml.sax.parse(xml_fn, handler) self.assertEqual(song("~#rating"), 0.4) self.assertEqual(song("~#lastplayed"), 1371802107)
def test_people(self): q = AudioFile([("performer:vocals", "A"), ("performer:guitar", "B"), ("performer", "C"), ("arranger", "A"), ("albumartist", "B"), ("artist", "C")]) self.failUnlessEqual(q.list("~people"), ["C", "B", "A"]) self.failUnlessEqual(q.list("~people:roles"), ["C", "B (Guitar)", "A (Arrangement, Vocals)"])
def test_has_rating(self): song = AudioFile() self.assertFalse(song.has_rating) song["~#rating"] = 0.5 self.assertTrue(song.has_rating) song.remove_rating() self.assertFalse(song.has_rating)
def setUp(self): self.rg_data = {"replaygain_album_gain": "-1.00 dB", "replaygain_album_peak": "1.1", "replaygain_track_gain": "+1.0000001 dB", "replaygain_track_peak": "0.9"} self.song = AudioFile(self.rg_data) self.no_rg_song = AudioFile()
def test_masked_handling(self): if os.name == "nt": # FIXME: masking isn't properly implemented on Windows return # playlists can contain songs and paths for masked handling.. lib = FileLibrary("foobar") with self.wrap("playlist", lib) as pl: song = Fakesong({"date": "2038", "~filename": fsnative(u"/fake")}) song.sanitize() lib.add([song]) # mask and update lib.mask("/") pl.append(song) pl.remove_songs([song]) self.failUnless("/fake" in pl) pl.extend(self.TWO_SONGS) # check if collections can handle the mix self.failUnlessEqual(pl("date"), "2038") # unmask and update lib.unmask("/") pl.add_songs(["/fake"], lib) self.failUnless(song in pl) lib.destroy()
class TRatingsMenuItem(TestCase): def setUp(self): config.RATINGS = config.HardCodedRatingsPrefs() self.failUnlessEqual(config.RATINGS.number, NUM_RATINGS) self.library = SongLibrary() self.library.librarian = SongLibrarian() self.af = AudioFile({"~filename": fsnative(u"/foo"), "~#rating": 1.0}) self.af.sanitize() self.rmi = RatingsMenuItem([self.af], self.library) def tearDown(self): self.rmi.destroy() self.library.destroy() self.library.librarian.destroy() def test_menuitem_children(self): children = [mi for mi in self.rmi.get_submenu().get_children() if isinstance(mi, Gtk.CheckMenuItem)] self.failUnlessEqual(len(children), NUM_RATINGS + 1) highest = children[-1] self.failUnlessEqual(highest.get_active(), True) self.failUnlessEqual(children[1].get_active(), False) def test_set_remove_rating(self): self.rmi.set_rating(0.5, [self.af], self.library) self.failUnless(self.af.has_rating) self.failUnlessEqual(self.af('~#rating'), 0.5) self.rmi.remove_rating([self.af], self.library) self.failIf(self.af.has_rating)
def test_msic(self): with realized(self.b): self.b.activate() self.b.status_text(1000) self.b.status_text(1) song = AudioFile({"~filename": dummy_path(u"/fake")}) song.sanitize() self.b.scroll(song)
def test_msic(self): with realized(self.b): self.b.activate() self.b.statusbar(1000) self.b.statusbar(1) song = AudioFile({"~filename": fsnative(u"/fake")}) song.sanitize() self.b.scroll(song)
def setUp(self): config.init() player = NullPlayer() song = AudioFile() song.bookmarks = [(10, "bla")] song.sanitize(fsnative(u"/")) player.song = song self.player = player self.library = SongLibrary()
def test_performers_multi_value(self): q = AudioFile([("performer:vocals", "X\nA\nY"), ("performer:guitar", "Y\nB\nA"), ("performer", "C\nF\nB\nA")]) self.failUnlessEqual(set(q.list("~performer")), {"A", "B", "C", "F", "X", "Y"}) self.failUnlessEqual( set(q.list("~performer:roles")), {"A (Guitar, Vocals)", "C", "B (Guitar)", "X (Vocals)", "Y (Guitar, Vocals)", "F"}, )
def test_people_mix(self): q = AudioFile([ ("performer:arrangement", "A"), ("arranger", "A"), ("performer", "A"), ("performer:foo", "A"), ]) self.failUnlessEqual(q.list("~people"), ["A"]) self.failUnlessEqual(q.list("~people:roles"), ["A (Arrangement, Arrangement, Foo)"])
def test_menuitem(self): library = SongLibrary() library.librarian = SongLibrarian() a = AudioFile({"~filename": fsnative(u"/foo")}) a.sanitize() x = RatingsMenuItem([a], library) x.set_rating(0, [a], library) x.destroy() library.destroy() library.librarian.destroy()
def _print_playing(app, fstring="<artist~album~tracknumber~title>"): from quodlibet.formats import AudioFile from quodlibet.pattern import Pattern song = app.player.info if song is None: song = AudioFile({"~filename": fsnative(u"/")}) song.sanitize() return Pattern(fstring).format(song) + "\n"
def test_remove_all(self): song = AudioFile() song.add("foo", "bar") song.add("foo", "another") song.add("foo", "one more") song.remove("foo") self.assertFalse("foo" in song)
def test_people_multi_value(self): q = AudioFile([ ("arranger", "A\nX"), ("performer", "A\nY"), ("performer:foo", "A\nX"), ]) self.failUnlessEqual(q.list("~people"), ["A", "Y", "X"]) self.failUnlessEqual( q.list("~people:roles"), ["A (Arrangement, Foo)", "Y", "X (Arrangement, Foo)"])
def test_list(self): for key in bar_1_1.realkeys(): self.failUnlessEqual(bar_1_1.list(key), [bar_1_1(key)]) af = AudioFile({"~filename": fsnative(u"foo")}) self.failUnlessEqual(af.list("artist"), []) self.failUnlessEqual(af.list("title"), [af("title")]) self.failUnlessEqual(af.list("not a key"), []) self.failUnlessEqual(len(bar_2_1.list("artist")), 2) self.failUnlessEqual(bar_2_1.list("artist"), bar_2_1["artist"].split("\n"))
def test_peoplesort(self): q = AudioFile([("performer:vocals", "The A"), ("performersort:vocals", "A, The"), ("performer:guitar", "The B"), ("performersort:guitar", "B, The"), ("performer", "The C"), ("performersort", "C, The"), ("albumartist", "The B"), ("albumartistsort", "B, The")]) self.failUnlessEqual(q.list("~peoplesort"), ["B, The", "C, The", "A, The"]) self.failUnlessEqual(q.list("~peoplesort:roles"), ["B, The (Guitar)", "C, The", "A, The (Vocals)"])
def getline(key, value): song = AudioFile({"~filename": "/dev/null"}) song.sanitize() song[key] = value lines = format_tags(song).splitlines() if not lines: return "" if len(lines) == 1: return lines[0] # hackery since title defaults to the filename.. for l in lines: if not l.startswith("Title"): return l
def test_to_dump(self): dump = bar_1_1.to_dump() num = len(set(bar_1_1.keys()) | INTERN_NUM_DEFAULT) self.failUnlessEqual(dump.count("\n"), num + 2) for key, value in bar_1_1.items(): self.failUnless(key in dump) self.failUnless(value in dump) for key in INTERN_NUM_DEFAULT: self.failUnless(key in dump) n = AudioFile() n.from_dump(dump) self.failUnless(set(dump.split("\n")) == set(n.to_dump().split("\n")))
def test_lyrics_from_file(self): with temp_filename() as filename: af = AudioFile(artist='Motörhead', title='this: again') af.sanitize(filename) lyrics = "blah!\nblasé 😬\n" lyrics_dir = os.path.dirname(af.lyric_filename) mkdir(lyrics_dir) with io.open(af.lyric_filename, "w", encoding='utf-8') as lf: lf.write(text_type(lyrics)) self.failUnlessEqual(af("~lyrics").splitlines(), lyrics.splitlines()) os.remove(af.lyric_filename) os.rmdir(lyrics_dir)
def test_sanitize(self): q = AudioFile(quux) b = AudioFile(bar_1_1) q.sanitize() b.pop("~filename") self.failUnlessRaises(ValueError, b.sanitize) n = AudioFile({"artist": u"foo\0bar", "title": u"baz\0", "~filename": fsnative(u"whatever")}) n.sanitize() self.failUnlessEqual(n["artist"], "foo\nbar") self.failUnlessEqual(n["title"], "baz")
def test_to_dump(self): dump = bar_1_1.to_dump() num = len(set(bar_1_1.keys()) | NUMERIC_ZERO_DEFAULT) self.failUnlessEqual(dump.count(b"\n"), num + 2) for key, value in bar_1_1.items(): self.failUnless(key.encode("utf-8") in dump) self.failUnless(value.encode("utf-8") in dump) for key in NUMERIC_ZERO_DEFAULT: self.failUnless(key.encode("utf-8") in dump) n = AudioFile() n.from_dump(dump) self.failUnless( set(dump.split(b"\n")) == set(n.to_dump().split(b"\n")))
def test_album_key(self): album_key_tests = [ ({}, ("", "", "")), ({"album": "foo"}, (("foo",), "", "")), ({"labelid": "foo"}, ("", "", "foo")), ({"musicbrainz_albumid": "foo"}, ("", "", "foo")), ({"album": "foo", "labelid": "bar"}, (("foo",), "", "bar")), ({"album": "foo", "labelid": "bar", "musicbrainz_albumid": "quux"}, (("foo",), "", "bar")), ({"albumartist": "a"}, ("", ("a",), "")), ] for tags, expected in album_key_tests: afile = AudioFile(**tags) afile.sanitize(fsnative(u"/dir/fn")) self.failUnlessEqual(afile.album_key, expected)
def test_list_sort_length_diff(self): s = AudioFile({"artist": "a\nb", "artistsort": "c"}) self.assertEqual(s.list_sort("artist"), [("a", "c"), ("b", "b")]) s = AudioFile({"artist": "a\nb", "artistsort": "c\nd\ne"}) self.assertEqual(s.list_sort("artist"), [("a", "c"), ("b", "d")]) s = AudioFile({"artistsort": "c\nd\ne"}) self.assertEqual(s.list_sort("artist"), []) s = AudioFile({"artist": "a\nb"}) self.assertEqual(s.list_sort("artist"), [("a", "a"), ("b", "b")]) s = AudioFile({}) self.assertEqual(s.list_sort("artist"), [])
def test_album_key(self): album_key_tests = [ ({}, ((), (), '')), ({'album': 'foo'}, (('foo',), (), '')), ({'labelid': 'foo'}, ((), (), 'foo')), ({'musicbrainz_albumid': 'foo'}, ((), (), 'foo')), ({'album': 'foo', 'labelid': 'bar'}, (('foo',), (), 'bar')), ({'album': 'foo', 'labelid': 'bar', 'musicbrainz_albumid': 'quux'}, (('foo',), (), 'bar')), ({'albumartist': 'a'}, ((), ('a',), '')), ] for tags, expected in album_key_tests: afile = AudioFile(**tags) afile.sanitize(fsnative(u'/dir/fn')) self.failUnlessEqual(afile.album_key, expected)
def test_save_ascii_keys_as_bytes_on_py3(self): i = AudioFile.__new__(list(formats.types)[0]) dict.__setitem__(i, u"foo", u"bar") data = dump_audio_files([i], process=True) if PY3: items = load_audio_files(data, process=False) assert isinstance(list(items[0].keys())[0], bytes)
def setUp(self): types = formats.types instances = [] for t in types: instances.append(AudioFile.__new__(t)) self.PICKLE = pickle.dumps(instances, 1)
def test_sort_func(self): tags = [lambda s: s("foo"), "artistsort", "albumsort", "~filename", "~format", "discnumber", "~#track"] for tag in tags: f = AudioFile.sort_by_func(tag) f(bar_1_1) f(bar_1_2) f(bar_2_1)
def test_set_bookmarks_invalid_time(self): self.failUnlessRaises(TypeError, setattr, AudioFile(), 'bookmarks', [("notint", "!")])
def test_performers(self): q = AudioFile([("performer:vocals", "A"), ("performer:guitar", "B"), ("performer", "C")]) self.failUnlessEqual(set(q.list("~performers")), {"A", "B", "C"}) self.failUnlessEqual(set(q.list("~performers:roles")), {"A (Vocals)", "B (Guitar)", "C"})
def test_bookmarks_simple(self): af = AudioFile({"~bookmark": "1:20 Mark 1"}) self.failUnlessEqual([(80, "Mark 1")], af.bookmarks)
def test(self): lib = SongFileLibrary() with temp_filename() as song_fn: song = AudioFile({"~filename": song_fn}) song.sanitize() lib.add([song]) # test recovery of basic song data = {"path": song("~filename"), "rating": 1, "playcount": 1, "skipcount": 2, "lastplayed": 1371802107, "added": 1260691996} db = get_example_db(data["path"], data["rating"], data["playcount"], data["skipcount"], data["lastplayed"], data["added"]) importer = self.mod.BansheeDBImporter(lib) importer.read(db) count = importer.finish() db.close() self.assertEqual(song("~#rating"), data["rating"] / 5.0) self.assertEqual(song("~#playcount"), data["playcount"]) self.assertEqual(song("~#skipcount"), data["skipcount"]) self.assertEqual(song("~#lastplayed"), data["lastplayed"]) self.assertEqual(song("~#added"), data["added"]) self.assertEqual(count, 1) # test recovery of different version of same song data_mod = {"path": song("~filename"), "rating": 2, "playcount": 4, "skipcount": 1, "lastplayed": data["lastplayed"] - 1, "added": data["added"] + 1} db = get_example_db(data_mod["path"], data_mod["rating"], data_mod["playcount"], data_mod["skipcount"], data_mod["lastplayed"], data_mod["added"]) importer = self.mod.BansheeDBImporter(lib) importer.read(db) count = importer.finish() db.close() self.assertEqual(song("~#rating"), data_mod["rating"] / 5.0) self.assertEqual(song("~#playcount"), data_mod["playcount"]) self.assertEqual(song("~#skipcount"), data_mod["skipcount"]) self.assertEqual(song("~#lastplayed"), data["lastplayed"]) self.assertEqual(song("~#added"), data["added"]) self.assertEqual(count, 1) # test that no recovery is performed when data is identical db = get_example_db(data_mod["path"], data_mod["rating"], data_mod["playcount"], data_mod["skipcount"], data_mod["lastplayed"], data_mod["added"]) importer = self.mod.BansheeDBImporter(lib) importer.read(db) count = importer.finish() db.close() self.assertEqual(count, 0)
def test_set_bookmarks_simple(self): af = AudioFile() af.bookmarks = [(120, "A mark"), (140, "Mark twain")] self.failUnlessEqual(af["~bookmark"], "2:00 A mark\n2:20 Mark twain")
def test_eq_ne(self): self.failIf(AudioFile({"a": "b"}) == AudioFile({"a": "b"})) self.failUnless(AudioFile({"a": "b"}) != AudioFile({"a": "b"}))
from gi.repository import Gtk from tests import TestCase, init_fake_app, destroy_fake_app from helper import realized, dummy_path from quodlibet import browsers from quodlibet.formats import AudioFile from quodlibet import config from quodlibet.browsers import Browser from quodlibet.library import SongFileLibrary, SongLibrarian SONGS = [ AudioFile({ "title": "one", "artist": "piman", "~filename": dummy_path(u"/dev/null"), }), AudioFile({ "title": "two", "artist": "mu", "~filename": dummy_path(u"/dev/zero"), }), AudioFile({ "title": "three", "artist": "boris", "~filename": dummy_path(u"/bin/ls"), }) ] SONGS.sort()
def test_website(self): song = AudioFile() song["comment"] = "www.foo" song["contact"] = "*****@*****.**" self.failUnlessEqual(song.website(), "www.foo") song["contact"] = "https://www.foo.org" self.failUnlessEqual(song.website(), "https://www.foo.org") song["website"] = "foo\nhttps://another.com" self.failUnlessEqual(song.website(), "foo") song = AudioFile({"artist": "Artist", "album": "Album"}) for value in song.values(): self.failUnless(value in song.website()) song["labelid"] = "QL-12345" self.failIf(song["artist"] in song.website()) self.failUnless(song["labelid"] in song.website())
# -*- coding: utf-8 -*- # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as # published by the Free Software Foundation from gi.repository import Gtk from senf import fsnative from tests import TestCase from quodlibet import config from quodlibet.formats import AudioFile from quodlibet.qltk.delete import DeleteDialog, TrashDialog, TrashMenuItem SONG = AudioFile({"~filename": fsnative(u"/dev/null")}) SONG.sanitize() class TDeleteDialog(TestCase): def setUp(self): config.init() def tearDown(self): config.quit() def test_delete_songs(self): dialog = DeleteDialog.for_songs(None, []) dialog.destroy() def test_delete_files(self):
def test_bookmarks_two(self): af = AudioFile({"~bookmark": "1:40 Mark 2\n1:20 Mark 1"}) self.failUnlessEqual([(80, "Mark 1"), (100, "Mark 2")], af.bookmarks)
from quodlibet import config from quodlibet.browsers.albums import AlbumList from quodlibet.browsers.albums.prefs import Preferences, DEFAULT_PATTERN_TEXT from quodlibet.browsers.albums.main import (compare_title, compare_artist, compare_genre, compare_rating, compare_date) from quodlibet.formats import AudioFile from quodlibet.library import SongLibrary, SongLibrarian from quodlibet.util.path import fsnative from quodlibet.util.collection import Album SONGS = [ AudioFile({ "album": "one", "artist": "piman", "~filename": fsnative(u"/dev/null"), }), AudioFile({ "album": "two", "artist": "mu", "~filename": fsnative(u"/dev/zero"), }), AudioFile({ "album": "three", "artist": "boris", "~filename": fsnative(u"/bin/ls"), }), AudioFile({ "album": "three", "artist": "boris",
class Treplay_gain(TestCase): # -6dB is approximately equal to half magnitude minus_6db = 0.501187234 def setUp(self): self.rg_data = { "replaygain_album_gain": "-1.00 dB", "replaygain_album_peak": "1.1", "replaygain_track_gain": "+1.0000001 dB", "replaygain_track_peak": "0.9" } self.song = AudioFile(self.rg_data) self.no_rg_song = AudioFile() def test_no_rg_song(self): scale = self.no_rg_song.replay_gain(["track"], 0, -6.0) self.failUnlessAlmostEqual(scale, self.minus_6db) scale = self.no_rg_song.replay_gain(["track"], +10, +10) self.failUnlessEqual(scale, 1.0) scale = self.no_rg_song.replay_gain(["track"], -16.0, +10) self.failUnlessAlmostEqual(scale, self.minus_6db) def test_nogain(self): self.failUnlessEqual(self.song.replay_gain(["none", "track"]), 1) def test_fallback_track(self): del (self.song["replaygain_track_gain"]) self.failUnlessAlmostEqual(self.song.replay_gain(["track"], 0, -6.0), self.minus_6db) def test_fallback_album(self): del (self.song["replaygain_album_gain"]) self.failUnlessAlmostEqual(self.song.replay_gain(["album"], 0, -6.0), self.minus_6db) def test_fallback_and_preamp(self): del (self.song["replaygain_track_gain"]) self.failUnlessEqual(self.song.replay_gain(["track"], 9, -9), 1) def test_preamp_track(self): self.failUnlessAlmostEqual(self.song.replay_gain(["track"], -7.0, 0), self.minus_6db) def test_preamp_album(self): self.failUnlessAlmostEqual(self.song.replay_gain(["album"], -5.0, 0), self.minus_6db) def test_preamp_clip(self): # Make sure excess pre-amp won't clip a track (with peak data) self.failUnlessAlmostEqual(self.song.replay_gain(["track"], 12.0, 0), 1.0 / 0.9) def test_trackgain(self): self.failUnless(self.song.replay_gain(["track"]) > 1) def test_albumgain(self): self.failUnless(self.song.replay_gain(["album"]) < 1) def test_invalid(self): self.song["replaygain_album_gain"] = "fdsodgbdf" self.failUnlessEqual(self.song.replay_gain(["album"]), 1) def test_track_fallback(self): radio_rg = self.song.replay_gain(["track"]) del (self.song["replaygain_album_gain"]) del (self.song["replaygain_album_peak"]) # verify defaulting to track when album is present self.failUnlessAlmostEqual(self.song.replay_gain(["album", "track"]), radio_rg) def test_numeric_rg_tags(self): """"Tests fully-numeric (ie no "db") RG tags. See Issue 865""" self.failUnless(self.song("replaygain_album_gain"), "-1.00 db") for key, exp in self.rg_data.items(): # Hack the nasties off and produce the "real" expected value exp = float(exp.split(" ")[0]) # Compare as floats. Seems fairer. album_rg = self.song("~#%s" % key) try: val = float(album_rg) except ValueError: self.fail("Invalid %s returned: %s" % (key, album_rg)) self.failUnlessAlmostEqual(val, exp, places=5, msg="%s should be %s not %s" % (key, exp, val))
class TPlaylistIntegration(TestCase): DUPLICATES = 1 SONG = AudioFile({ "title": "two", "artist": "mu", "~filename": dummy_path(u"/dev/zero") }) SONGS = [ AudioFile({ "title": "one", "artist": "piman", "~filename": dummy_path(u"/dev/null") }), SONG, AudioFile({ "title": "three", "artist": "boris", "~filename": dummy_path(u"/bin/ls") }), AudioFile({ "title": "four", "artist": "random", "album": "don't stop", "labelid": "65432-1", "~filename": dummy_path(u"/dev/random") }), SONG, ] def setUp(self): quodlibet.config.init() self.lib = quodlibet.browsers.tracks.library = FileLibrary() quodlibet.browsers.tracks.library.librarian = SongLibrarian() for af in self.SONGS: af.sanitize() self.lib.add(self.SONGS) self._dir = mkdtemp() self.pl = FileBackedPlaylist.new(self._dir, "Foobar", self.lib) self.pl.extend(self.SONGS) def tearDown(self): self.pl.delete() self.lib.destroy() self.lib.librarian.destroy() quodlibet.config.quit() shutil.rmtree(self._dir) def test_remove_song(self): # Check: library should have one song fewer (the duplicate) self.failUnlessEqual(len(self.lib), len(self.SONGS) - self.DUPLICATES) self.failUnlessEqual(len(self.pl), len(self.SONGS)) # Remove an unduplicated song self.pl.remove_songs([self.SONGS[0]]) self.failUnlessEqual(len(self.pl), len(self.SONGS) - 1) def test_remove_duplicated_song(self): self.failUnlessEqual(self.SONGS[1], self.SONGS[4]) self.pl.remove_songs([self.SONGS[1]]) self.failUnlessEqual(len(self.pl), len(self.SONGS) - 2) def test_remove_multi_duplicated_song(self): self.pl.extend([self.SONG, self.SONG]) self.failUnlessEqual(len(self.pl), 7) self.pl.remove_songs([self.SONG], False) self.failUnlessEqual(len(self.pl), 7 - 2 - 2) def test_remove_duplicated_song_leave_dupes(self): self.pl.remove_songs([self.SONGS[1]], True) self.failUnlessEqual(len(self.pl), len(self.SONGS) - 1) def test_remove_no_lib(self): pl = FileBackedPlaylist.new(self._dir, "Foobar") pl.extend(self.SONGS) self.assertTrue(len(pl)) pl.remove_songs(self.SONGS, False) self.assertFalse(len(pl))
def test_change(self): song = AudioFile() song.add("foo", "bar") song.add("foo", "another") song.change("foo", "bar", "one more") self.failUnlessEqual(song.list("foo"), ["one more", "another"]) song.change("foo", "does not exist", "finally") self.failUnlessEqual(song["foo"], "finally") song.change("foo", "finally", "we're done") self.failUnlessEqual(song["foo"], "we're done")
def test_set_bookmarks_invalid_value(self): self.failUnlessRaises(ValueError, setattr, AudioFile(), 'bookmarks', "huh?")
# -*- coding: utf-8 -*- from tests import TestCase, DATA_DIR import os from quodlibet import config from quodlibet.util.path import is_fsnative, fsnative, fsdecode from quodlibet.compat import PY2 from quodlibet.formats import AudioFile from quodlibet.formats._audio import INTERN_NUM_DEFAULT from quodlibet.formats import decode_value bar_1_1 = AudioFile({ "~filename": fsnative(u"/fakepath/1"), "title": "A song", "discnumber": "1/2", "tracknumber": "1/3", "artist": "Foo", "album": "Bar" }) bar_1_2 = AudioFile({ "~filename": fsnative(u"/fakepath/2"), "title": "Perhaps another", "discnumber": "1", "tracknumber": "2/3", "artist": "Lali-ho!", "album": "Bar", "date": "2004-12-12", "originaldate": "2005-01-01", "~#filesize": 1024**2, "~#bitrate": 128 })
def test_sanitize(self): q = AudioFile(quux) b = AudioFile(bar_1_1) q.sanitize() b.pop('~filename') self.failUnlessRaises(ValueError, b.sanitize) n = AudioFile({ "artist": u"foo\0bar", "title": u"baz\0", "~filename": fsnative(u"whatever") }) n.sanitize() self.failUnlessEqual(n["artist"], "foo\nbar") self.failUnlessEqual(n["title"], "baz")
def test_set_bookmarks_unrealistic_time(self): self.failUnlessRaises(ValueError, setattr, AudioFile(), 'bookmarks', [(-1, "!")])
def test_bookmarks_none(self): self.failUnlessEqual([], AudioFile().bookmarks)
def test_remove_empty(self): song = AudioFile() song.add("foo", u"") song.remove("foo", u"") self.assertFalse("foo" in song)
from tests import TestCase, skipUnless, AbstractTestCase from quodlibet import player from quodlibet import library from quodlibet import config from quodlibet.util.path import fsnative from quodlibet.util import connect_obj from quodlibet.player.nullbe import NullPlayer from quodlibet.formats import AudioFile from quodlibet.qltk.songmodel import PlaylistModel from quodlibet.qltk.controls import Volume FILES = [ AudioFile({ "~filename": fsnative(u"/foo/bar1"), "title": "1" }), AudioFile({ "~filename": fsnative(u"/foo/bar2"), "title": "2" }), AudioFile({ "~filename": fsnative(u"/foo/bar3"), "title": "3" }), ] for file_ in FILES: file_.sanitize() UNKNOWN_FILE = FILES.pop(-1)
def test_remove(self): song = AudioFile() song.add("foo", "bar") song.add("foo", "another") song.add("foo", "one more") song.remove("foo", "another") self.failUnlessEqual(song.list("foo"), ["bar", "one more"]) song.remove("foo", "bar") self.failUnlessEqual(song.list("foo"), ["one more"]) song.remove("foo", "one more") self.failIf("foo" in song)
def parse(self): try: doc = feedparser.parse(self.uri) except Exception as e: print_w("Couldn't parse feed: %s (%s)" % (self.uri, e)) return False try: album = doc.channel.title except AttributeError: print_w("No channel title in %s" % doc) return False if album: self.name = album else: self.name = _("Unknown") defaults = AudioFile({"feed": self.uri}) try: self.__fill_af(doc.channel, defaults) except Exception as e: print_w("Error creating feed data: %s (%s)" % (self.uri, e)) return False entries = [] uris = set() print_d("Found %d entries in channel" % len(doc.entries)) for entry in doc.entries: try: for enclosure in entry.enclosures: try: if ("audio" in enclosure.type or "ogg" in enclosure.type or formats.filter(enclosure.url)): uri = enclosure.url if not isinstance(uri, str): uri = uri.decode('utf-8') try: size = float(enclosure.length) except (AttributeError, ValueError): size = 0 entries.append((uri, entry, size)) uris.add(uri) break except AttributeError: pass except AttributeError: print_d("No enclosures found in %s" % entry) for entry in list(self): if entry["~uri"] not in uris: self.remove(entry) else: uris.remove(entry["~uri"]) print_d("Successfully got %d episodes in channel" % len(entries)) entries.reverse() for uri, entry, size in entries: if uri in uris: song = RemoteFile(uri) song["~#size"] = size song.fill_metadata = False song.update(defaults) song["album"] = self.name try: self.__fill_af(entry, song) except Exception as e: print_d("Couldn't convert %s to AudioFile (%s)" % (uri, e)) else: self.insert(0, song) self.__lastgot = time.time() return bool(uris)
def test_set_bookmarks_none(self): af = AudioFile({"bookmark": "foo"}) af.bookmarks = [] self.failUnlessEqual([], AudioFile().bookmarks) self.failIf("~bookmark" in af)
def AF(*args, **kwargs): a = AudioFile(*args, **kwargs) a.sanitize() return a
from senf import fsnative from tests import TestCase, skipUnless, get_data_path from quodlibet import player from quodlibet import library from quodlibet import config from quodlibet.util import connect_obj from quodlibet.player.nullbe import NullPlayer from quodlibet.formats import AudioFile from quodlibet.qltk.songmodel import PlaylistModel from quodlibet.qltk.controls import Volume FILES = [ AudioFile({ "~filename": fsnative(u"/foo/bar1"), "title": "1" }), AudioFile({ "~filename": fsnative(u"/foo/bar2"), "title": "2" }), AudioFile({ "~filename": fsnative(u"/foo/bar3"), "title": "3" }), ] for file_ in FILES: file_.sanitize() UNKNOWN_FILE = FILES.pop(-1)
class TPlaylistsBrowser(TestCase): Bar = PlaylistsBrowser ANOTHER_SONG = AudioFile({ "title": "lonely", "artist": "new artist", "~filename": dummy_path(u"/dev/urandom") }) def setUp(self): self.success = False # Testing locally is VERY dangerous without this... self.assertTrue(_TEMP_DIR in PLAYLISTS or os.name == "nt", msg="Failing, don't want to delete %s" % PLAYLISTS) try: shutil.rmtree(PLAYLISTS) except OSError: pass mkdir(PLAYLISTS) init_fake_app() self.lib = quodlibet.browsers.playlists.library = SongFileLibrary() self.lib.librarian = SongLibrarian() all_songs = SONGS + [self.ANOTHER_SONG] for af in all_songs: af.sanitize() self.lib.add(all_songs) self.big = pl = FileBackedPlaylist.new(PLAYLISTS, "Big", self.lib) pl.extend(SONGS) pl.write() self.small = pl = FileBackedPlaylist.new(PLAYLISTS, "Small", self.lib) pl.extend([self.ANOTHER_SONG]) pl.write() PlaylistsBrowser.init(self.lib) self.bar = PlaylistsBrowser(self.lib) self.bar.connect('songs-selected', self._expected) self.bar._select_playlist(self.bar.playlists()[0]) self.expected = None def tearDown(self): self.bar.destroy() self.lib.destroy() shutil.rmtree(PLAYLISTS) PlaylistsBrowser.deinit(self.lib) destroy_fake_app() def _expected(self, bar, songs, sort): songs.sort() if self.expected is not None: self.failUnlessEqual(self.expected, songs) self.success = True def _do(self): while Gtk.events_pending(): Gtk.main_iteration() self.failUnless(self.success or self.expected is None) def test_saverestore(self): # Flush previous signals, etc. Hmm. self.expected = None self._do() self.expected = [SONGS[0]] self.bar.filter_text("title = %s" % SONGS[0]["title"]) self.bar._select_playlist(self.bar.playlists()[0]) self.expected = [SONGS[0]] self._do() self.bar.save() self.bar.filter_text("") self.expected = list(sorted(SONGS)) self._do() self.bar.restore() self.bar.activate() self.expected = [SONGS[0]] self._do() def test_active_filter_playlists(self): self.bar._select_playlist(self.bar.playlists()[1]) # Second playlist should not have any of `SONGS` self.assertFalse(self.bar.active_filter(SONGS[0])) # But it should have `ANOTHER_SONG` self.assertTrue(self.bar.active_filter(self.ANOTHER_SONG), msg="Couldn't find song from second playlist") # ... and setting a reasonable filter on that song should match still self.bar.filter_text("lonely") self.assertTrue(self.bar.active_filter(self.ANOTHER_SONG), msg="Couldn't find song from second playlist with " "filter of 'lonely'") # ...unless it doesn't match that song self.bar.filter_text("piman") self.assertFalse(self.bar.active_filter(self.ANOTHER_SONG), msg="Shouldn't have matched 'piman' on second list") def test_rename(self): self.assertEquals(self.bar.playlists()[1], self.small) self.bar._rename(0, "zBig") self.assertEquals(self.bar.playlists()[0], self.small) self.assertEquals(self.bar.playlists()[1].name, "zBig") def test_default_display_pattern(self): pattern_text = self.bar.display_pattern_text self.failUnlessEqual(pattern_text, DEFAULT_PATTERN_TEXT) self.failUnless("<~name>" in pattern_text) def test_drag_data_get(self): b = self.bar song = AudioFile() song["~filename"] = fsnative(u"foo") sel = MockSelData() qltk.selection_set_songs(sel, [song]) b._drag_data_get(None, None, sel, DND_QL, None) def test_deletion(self): def a_delete_event(): ev = Gdk.Event() ev.type = Gdk.EventType.KEY_PRESS ev.keyval, accel_mod = Gtk.accelerator_parse("Delete") ev.state = Gtk.accelerator_get_default_mod_mask() & accel_mod return ev b = self.bar self._fake_browser_pack(b) event = a_delete_event() # This is selected in setUp() first_pl = b.playlists()[0] app.window.songlist.set_songs(first_pl) app.window.songlist.select_by_func(lambda x: True, scroll=False, one=True) original_length = len(first_pl) ret = b.key_pressed(event) self.failUnless(ret, msg="Didn't simulate a delete keypress") self.failUnlessEqual(len(first_pl), original_length - 1) def test_import(self): pl_name = u"_€3 œufs à Noël" pl = FileBackedPlaylist(_TEMP_DIR, pl_name, None) pl.extend(SONGS) pl.write() new_fn = os.path.splitext(text2fsn(pl.name))[0] + '.m3u' new_path = os.path.join(pl.dir, new_fn) os.rename(pl.path, new_path) added = self.bar._import_playlists([new_path], self.lib) self.failUnlessEqual(added, 1, msg="Failed to add '%s'" % new_path) os.unlink(new_path) pls = self.bar.playlists() self.failUnlessEqual(len(pls), 3) # Leading underscore makes it always the last entry imported = pls[-1] self.failUnlessEqual(imported.name, pl_name) def fns(songs): return [song('~filename') for song in songs] self.failUnlessEqual(fns(imported.songs), fns(pl.songs)) @staticmethod def _fake_browser_pack(b): app.window.get_child().pack_start(b, True, True, 0)
def test_remove_unknown(self): song = AudioFile() song.add("foo", "bar") song.remove("foo", "not in list") song.remove("nope") self.failUnlessEqual(song.list("foo"), ["bar"])
def test_cache_attributes(self): x = AudioFile() x.multisong = not x.multisong x["a"] = "b" # clears cache # attribute should be unchanged self.failIfEqual(AudioFile().multisong, x.multisong)
# # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. from quodlibet.formats import AudioFile from quodlibet.qltk.cover import ALBUM_ART_PLUGIN_ID from tests.plugin import PluginTestCase from quodlibet import library, config from quodlibet import app A_SONG = AudioFile({ '~filename': '/dev/null', 'artist': 'Mr Man', 'album': 'Bars of Foo' }) # Keep IDEs happy DownloadAlbumArt = AlbumArtWindow = CoverArea = None # TODO: Some real tests. class TAlbumArt(PluginTestCase): @classmethod def setUpClass(cls): app.library = library.init() config.init() @classmethod