def setUp(self): config.init() self.main = mkdtemp() self.dir1 = mkdtemp(dir=self.main) self.dir2 = mkdtemp(dir=self.main) h, self.cover1 = mkstemp(".png", dir=self.main) os.close(h) pb = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8, 10, 10) pb.savev(self.cover1, "png", [], []) h, self.cover2 = mkstemp(".png", dir=self.main) os.close(h) pb = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8, 20, 20) pb.savev(self.cover2, "png", [], []) fd, self.file1 = mkstemp(".mp3", dir=self.main) os.close(fd) shutil.copy(os.path.join(DATA_DIR, 'silence-44-s.mp3'), self.file1) fd, self.file2 = mkstemp(".mp3", dir=self.main) os.close(fd) shutil.copy(os.path.join(DATA_DIR, 'silence-44-s.mp3'), self.file2) self.manager = CoverManager()
def setUp(self): config.init() self.manager = CoverManager() self.dir = os.path.realpath(quux("~dirname")) self.files = [self.full_path("12345.jpg"), self.full_path("nothing.jpg") ] for f in self.files: file(f, "w").close()
def setUp(self): self.manager = CoverManager() self.dir = mkdtemp() self.song = self.an_album_song() # Safety check self.failIf(glob.glob(os.path.join(self.dir + "*.jpg"))) files = [self.full_path("12345.jpg"), self.full_path("nothing.jpg")] for f in files: open(f, "w").close()
def setUp(self): config.init() self.manager = CoverManager() self.dir = os.path.realpath(quux("~dirname")) # Safety check self.failIf(glob.glob(self.dir + "/*.jpg")) self.files = [self.full_path("12345.jpg"), self.full_path("nothing.jpg") ] for f in self.files: open(f, "w").close()
def test_acquire_cover(self): manager = CoverManager(use_built_in=False) handler = manager.plugin_handler for source in dummy_sources: handler.plugin_handle(source) handler.plugin_enable(dummy_sources[0]) found = [] result = [] def done(_found, _result): found.append(_found) result.append(_result) manager.acquire_cover(done, None, None) self.runLoop() self.assertFalse(found[0]) handler.plugin_enable(dummy_sources[1]) manager.acquire_cover(done, None, None) self.runLoop() self.assertTrue(found[1]) self.assertIs(result[1], DUMMY_COVER) handler.plugin_disable(dummy_sources[1]) handler.plugin_enable(dummy_sources[2]) manager.acquire_cover(done, None, None) self.runLoop() self.assertTrue(found[2]) self.assertIs(result[2], DUMMY_COVER)
def setUp(self): self.manager = CoverManager() self.dir = mkdtemp() self.song = AudioFile({ "~filename": os.path.join(self.dir, "asong.ogg"), "album": u"Quuxly", }) # Safety check self.failIf(glob.glob(os.path.join(self.dir + "*.jpg"))) files = [self.full_path("12345.jpg"), self.full_path("nothing.jpg")] for f in files: open(f, "w").close()
def test_search(self): manager = CoverManager(use_built_in=False) handler = manager.plugin_handler for source in dummy_sources: handler.plugin_handle(source) handler.plugin_enable(source) source.cls.cover_call = False source.cls.fetch_call = False song = AudioFile({ "~filename": os.path.join("/tmp/asong.ogg"), "album": "Abbey Road", "artist": "The Beatles" }) songs = [song] results = [] def done(manager, provider, result): self.failUnless(result, msg="Shouldn't succeed with no results") results.append(result) def finished(manager, songs): print("Finished!") manager.connect('covers-found', done) manager.search_cover(Cancellable(), songs) manager.connect('searches-complete', finished) run_loop() self.failUnlessEqual(len(results), 1)
def test_acquire_cover_sync(self): song = AudioFile({"~filename": "/dev/null"}) manager = CoverManager(use_built_in=False) handler = manager.plugin_handler for source in dummy_sources: handler.plugin_handle(source) handler.plugin_enable(dummy_sources[0]) self.assertIs(manager.acquire_cover_sync(song), None) handler.plugin_enable(dummy_sources[1]) self.assertIs(manager.acquire_cover_sync(song), DUMMY_COVER) handler.plugin_enable(dummy_sources[2]) self.assertIs(manager.acquire_cover_sync(song), DUMMY_COVER) handler.plugin_disable(dummy_sources[1]) self.assertIs(manager.acquire_cover_sync(song), None)
def test_acquire_cover_calls(self): # * fetch_cover shouldn't get called if source provides the cover # synchronously # * First cover source should fail providing the cover both # synchronously and asynchronously and only then the next source # should be used manager = CoverManager(use_built_in=False) handler = manager.plugin_handler found = [] result = [] for source in dummy_sources: handler.plugin_handle(source) handler.plugin_enable(source) source.cls.cover_call = False source.cls.fetch_call = False def done(_found, _result): found.append(_found) result.append(_result) manager.acquire_cover(done, None, None) self.runLoop() self.assertTrue(found[0]) self.assertIs(result[0], DUMMY_COVER) self.assertTrue(dummy_sources[0].cls.cover_call) self.assertTrue(dummy_sources[1].cls.cover_call) self.assertFalse(dummy_sources[2].cls.cover_call) self.assertFalse(dummy_sources[0].cls.fetch_call) self.assertFalse(dummy_sources[1].cls.fetch_call) self.assertFalse(dummy_sources[2].cls.fetch_call) for source in dummy_sources: source.cls.cover_call = False source.cls.fetch_call = False handler.plugin_disable(dummy_sources[1]) manager.acquire_cover(done, None, None) self.runLoop() self.assertTrue(found[1]) self.assertIs(result[1], DUMMY_COVER) self.assertTrue(dummy_sources[0].cls.cover_call) self.assertFalse(dummy_sources[1].cls.cover_call) self.assertTrue(dummy_sources[2].cls.cover_call) self.assertFalse(dummy_sources[0].cls.fetch_call) self.assertFalse(dummy_sources[1].cls.fetch_call) self.assertTrue(dummy_sources[2].cls.fetch_call)
def setUp(self): config.init() self.manager = CoverManager() self.dir = mkdtemp() self.song = self.an_album_song() # Safety check self.failIf(glob.glob(os.path.join(self.dir + "*.jpg"))) files = [self.full_path("12345.jpg"), self.full_path("nothing.jpg")] for f in files: open(f, "w").close()
def setUp(self): config.init() self.main = mkdtemp() self.dir1 = mkdtemp(dir=self.main) self.dir2 = mkdtemp(dir=self.main) h, self.cover1 = mkstemp(".png", dir=self.main) os.close(h) pb = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8, 10, 10) pb.savev(self.cover1, "png", [], []) h, self.cover2 = mkstemp(".png", dir=self.main) os.close(h) pb = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8, 20, 20) pb.savev(self.cover2, "png", [], []) self.file1 = get_temp_copy(get_data_path('silence-44-s.mp3')) self.file2 = get_temp_copy(get_data_path('silence-44-s.mp3')) self.manager = CoverManager()
class TCoverManagerBuiltin(TestCase): def setUp(self): config.init() self.main = mkdtemp() self.dir1 = mkdtemp(dir=self.main) self.dir2 = mkdtemp(dir=self.main) h, self.cover1 = mkstemp(".png", dir=self.main) os.close(h) pb = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8, 10, 10) pb.savev(self.cover1, "png", [], []) h, self.cover2 = mkstemp(".png", dir=self.main) os.close(h) pb = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8, 20, 20) pb.savev(self.cover2, "png", [], []) fd, self.file1 = mkstemp(".mp3", dir=self.main) os.close(fd) shutil.copy(os.path.join(DATA_DIR, 'silence-44-s.mp3'), self.file1) fd, self.file2 = mkstemp(".mp3", dir=self.main) os.close(fd) shutil.copy(os.path.join(DATA_DIR, 'silence-44-s.mp3'), self.file2) self.manager = CoverManager() def tearDown(self): shutil.rmtree(self.main) config.quit() def test_connect_cover_changed(self): called_with = [] def sig_handler(*args): called_with.extend(args) obj = object() self.manager.connect("cover-changed", sig_handler) self.manager.cover_changed([obj]) self.assertEqual(called_with, [self.manager, [obj]]) def test_get_primary_image(self): self.assertFalse(MP3File(self.file1).has_images) self.assertFalse(MP3File(self.file1).has_images) def test_manager(self): self.assertEqual(len(list(self.manager.sources)), 2) def test_main(self): # embedd one cover, move one to the other dir MP3File(self.file1).set_image(EmbeddedImage.from_path(self.cover1)) os.unlink(self.cover1) dest = os.path.join(self.dir2, "cover.png") shutil.move(self.cover2, dest) self.cover2 = dest # move one audio file in each dir shutil.move(self.file1, self.dir1) self.file1 = os.path.join(self.dir1, os.path.basename(self.file1)) shutil.move(self.file2, self.dir2) self.file2 = os.path.join(self.dir2, os.path.basename(self.file2)) song1 = MP3File(self.file1) song2 = MP3File(self.file2) def is_embedded(fileobj): return not path_equal(fileobj.name, self.cover2, True) # each should find a cover self.assertTrue(is_embedded(self.manager.get_cover(song1))) self.assertTrue(not is_embedded(self.manager.get_cover(song2))) # both settings should search both songs before giving up config.set("albumart", "prefer_embedded", True) self.assertTrue( is_embedded(self.manager.get_cover_many([song1, song2]))) self.assertTrue( is_embedded(self.manager.get_cover_many([song2, song1]))) config.set("albumart", "prefer_embedded", False) self.assertTrue( not is_embedded(self.manager.get_cover_many([song1, song2]))) self.assertTrue( not is_embedded(self.manager.get_cover_many([song2, song1])))
class TCoverManagerBuiltin(TestCase): def setUp(self): config.init() self.main = mkdtemp() self.dir1 = mkdtemp(dir=self.main) self.dir2 = mkdtemp(dir=self.main) h, self.cover1 = mkstemp(".png", dir=self.main) os.close(h) pb = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8, 10, 10) pb.savev(self.cover1, "png", [], []) h, self.cover2 = mkstemp(".png", dir=self.main) os.close(h) pb = GdkPixbuf.Pixbuf.new(GdkPixbuf.Colorspace.RGB, True, 8, 20, 20) pb.savev(self.cover2, "png", [], []) self.file1 = get_temp_copy(get_data_path('silence-44-s.mp3')) self.file2 = get_temp_copy(get_data_path('silence-44-s.mp3')) self.manager = CoverManager() def tearDown(self): shutil.rmtree(self.main) config.quit() def test_connect_cover_changed(self): called_with = [] def sig_handler(*args): called_with.extend(args) obj = object() self.manager.connect("cover-changed", sig_handler) self.manager.cover_changed([obj]) self.assertEqual(called_with, [self.manager, [obj]]) def test_get_primary_image(self): self.assertFalse(MP3File(self.file1).has_images) self.assertFalse(MP3File(self.file1).has_images) def test_manager(self): self.assertEqual(len(list(self.manager.sources)), 2) def test_get_cover_many_prefer_embedded(self): # embed one cover, move one to the other dir MP3File(self.file1).set_image(EmbeddedImage.from_path(self.cover1)) os.unlink(self.cover1) self.external_cover = os.path.join(self.dir2, "cover.png") shutil.move(self.cover2, self.external_cover) # move one audio file in each dir shutil.move(self.file1, self.dir1) self.file1 = os.path.join(self.dir1, os.path.basename(self.file1)) shutil.move(self.file2, self.dir2) self.file2 = os.path.join(self.dir2, os.path.basename(self.file2)) song1 = MP3File(self.file1) song2 = MP3File(self.file2) # each should find a cover self.failUnless(self.is_embedded(self.manager.get_cover(song1))) self.failIf(self.is_embedded(self.manager.get_cover(song2))) cover_for = self.manager.get_cover_many # both settings should search both songs before giving up config.set("albumart", "prefer_embedded", True) self.failUnless(self.is_embedded(cover_for([song1, song2]))) self.failUnless(self.is_embedded(cover_for([song2, song1]))) config.set("albumart", "prefer_embedded", False) self.failIf(self.is_embedded(cover_for([song1, song2]))) self.failIf(self.is_embedded(cover_for([song2, song1]))) def is_embedded(self, fileobj): return not path_equal(fileobj.name, self.external_cover, True) def test_acquire_prefer_embedded(self): # embed one cover... MP3File(self.file1).set_image(EmbeddedImage.from_path(self.cover1)) os.unlink(self.cover1) self.external_cover = os.path.join(self.dir1, "cover.png") # ...and save a different cover externally shutil.copy(self.cover2, self.external_cover) shutil.move(self.file1, self.dir1) self.file1 = os.path.join(self.dir1, os.path.basename(self.file1)) both_song = MP3File(self.file1) results = [] def acquire(song): def cb(source, result): results.append(result) self.manager.acquire_cover(cb, None, song) def result_was_embedded(): return self.is_embedded(results.pop()) config.set("albumart", "prefer_embedded", True) acquire(both_song) self.failUnless(result_was_embedded(), "Embedded image expected due to prefs") config.set("albumart", "prefer_embedded", False) acquire(both_song) self.failIf(result_was_embedded(), "Got an embedded image despite prefs")
class TCoverManager(TestCase): def setUp(self): config.init() self.manager = CoverManager() self.dir = os.path.realpath(quux("~dirname")) self.files = [self.full_path("12345.jpg"), self.full_path("nothing.jpg") ] for f in self.files: file(f, "w").close() def _find_cover(self, song): return self.manager.get_cover(song) def tearDown(self): for f in self.files: os.unlink(f) config.quit() def full_path(self, path): return os.path.join(self.dir, path) def test_dir_not_exist(self): self.failIf(self._find_cover(bar_2_1)) def test_nothing(self): self.failIf(self._find_cover(quux)) def test_labelid(self): quux["labelid"] = "12345" self.failUnlessEqual(os.path.abspath(self._find_cover(quux).name), self.full_path("12345.jpg")) del(quux["labelid"]) def test_regular(self): files = [os.path.join(self.dir, f) for f in ["cover.png", "folder.jpg", "frontcover.jpg", "front_folder_cover.gif", "jacket_cover.front.folder.jpeg"]] for f in files: file(f, "w").close() self.files.append(f) self.failUnlessEqual( os.path.abspath(self._find_cover(quux).name), f) self.test_labelid() # labelid must work with other files present def test_file_encoding(self): if os.name == "nt": return f = self.full_path("\xff\xff\xff\xff - cover.jpg") file(f, "w").close() self.files.append(f) self.assertTrue(isinstance(quux("album"), unicode)) h = self._find_cover(quux) self.assertEqual(h.name, normalize_path(f)) def test_intelligent(self): song = quux song["artist"] = "Q-Man" song["title"] = "First Q falls hardest" files = [self.full_path(f) for f in ["Quuxly - back.jpg", "Quuxly.jpg", "q-man - quxxly.jpg", "folder.jpeg", "Q-man - Quuxly (FRONT).jpg"]] for f in files: file(f, "w").close() self.files.append(f) cover = self._find_cover(song) if cover: actual = os.path.abspath(cover.name) self.failUnlessEqual(actual, f) else: # Here, no cover is better than the back... self.failUnlessEqual(f, self.full_path("Quuxly - back.jpg")) def test_embedded_special_cover_words(self): """Tests that words incidentally containing embedded "special" words album keywords (e.g. cover, disc, back) don't trigger See Issue 818""" song = AudioFile({ "~filename": fsnative(u"tests/data/asong.ogg"), "album": "foobar", "title": "Ode to Baz", "artist": "Q-Man", }) files = [self.full_path(f) for f in ['back.jpg', 'discovery.jpg', "Pharell - frontin'.jpg", 'nickelback - Curb.jpg', 'foobar.jpg', 'folder.jpg', # Though this is debatable 'Q-Man - foobar.jpg', 'Q-man - foobar (cover).jpg']] for f in files: file(f, "w").close() self.files.append(f) cover = self._find_cover(song) if cover: actual = os.path.abspath(cover.name) self.failUnlessEqual( actual, f, "\"%s\" should trump \"%s\"" % (f, actual)) else: self.failUnless(f, self.full_path('back.jpg')) def test_get_thumbnail(self): self.assertTrue(self.manager.get_pixbuf(quux, 10, 10) is None) self.assertTrue(self.manager.get_pixbuf_many([quux], 10, 10) is None)
class TCoverManager(TestCase): def setUp(self): self.manager = CoverManager() self.dir = mkdtemp() self.song = AudioFile({ "~filename": os.path.join(self.dir, "asong.ogg"), "album": u"Quuxly", }) # Safety check self.failIf(glob.glob(os.path.join(self.dir + "*.jpg"))) files = [self.full_path("12345.jpg"), self.full_path("nothing.jpg")] for f in files: open(f, "w").close() def tearDown(self): shutil.rmtree(self.dir) def _find_cover(self, song): return self.manager.get_cover(song) def full_path(self, path): return os.path.join(self.dir, path) def test_dir_not_exist(self): self.failIf(self._find_cover(bar_2_1)) def test_nothing(self): self.failIf(self._find_cover(self.song)) def test_labelid(self): self.song["labelid"] = "12345" assert path_equal(os.path.abspath(self._find_cover(self.song).name), self.full_path("12345.jpg")) del (self.song["labelid"]) def test_regular(self): for fn in [ "cover.png", "folder.jpg", "frontcover.jpg", "front_folder_cover.gif", "jacket_cover.front.folder.jpeg" ]: f = self.add_file(fn) assert path_equal( os.path.abspath(self._find_cover(self.song).name), f) self.test_labelid() # labelid must work with other files present def test_file_encoding(self): if os.name == "nt": return f = self.add_file("\xff\xff\xff\xff - cover.jpg") self.assertTrue(isinstance(self.song("album"), unicode)) h = self._find_cover(self.song) self.assertEqual(h.name, normalize_path(f)) def test_intelligent(self): song = self.song song["artist"] = "Q-Man" song["title"] = "First Q falls hardest" fns = [ "Quuxly - back.jpg", "Quuxly.jpg", "q-man - quxxly.jpg", "folder.jpeg", "Q-man - Quuxly (FRONT).jpg" ] for fn in fns: f = self.add_file(fn) cover = self._find_cover(song) if cover: actual = os.path.abspath(cover.name) assert path_equal(actual, f) else: # Here, no cover is better than the back... assert path_equal(f, self.full_path("Quuxly - back.jpg")) def test_embedded_special_cover_words(self): """Tests that words incidentally containing embedded "special" words album keywords (e.g. cover, disc, back) don't trigger See Issue 818""" song = AudioFile({ "~filename": fsnative(os.path.join(self.dir, u"asong.ogg")), "album": "foobar", "title": "Ode to Baz", "artist": "Q-Man", }) data = [ ('back.jpg', False), ('discovery.jpg', False), ("Pharell - frontin'.jpg", False), ('nickelback - Curb.jpg', False), ('foobar.jpg', True), ('folder.jpg', True), # Though this order is debatable ('Q-Man - foobar.jpg', True), ('Q-man - foobar (cover).jpg', True) ] for fn, should_find in data: f = self.add_file(fn) cover = self._find_cover(song) if cover: actual = os.path.abspath(cover.name) assert path_equal(actual, f, "\"%s\" should trump \"%s\"" % (f, actual)) else: self.failIf(should_find, msg="Couldn't find %s for %s" % (f, song("~filename"))) def add_file(self, fn): f = self.full_path(fn) open(f, "w").close() return f def test_multiple_people(self): song = AudioFile({ "~filename": os.path.join(self.dir, "asong.ogg"), "album": "foobar", "title": "Ode to Baz", "performer": "The Performer", "artist": "The Composer\nThe Conductor", "composer": "The Composer", }) for fn in [ "foobar.jpg", "The Performer - foobar.jpg", "The Composer - The Performer - foobar.jpg", "The Composer - The Conductor, The Performer - foobar.jpg" ]: f = self.add_file(fn) cover = self._find_cover(song) self.failUnless(cover) actual = os.path.abspath(cover.name) cover.close() assert path_equal(actual, f, "\"%s\" should trump \"%s\"" % (f, actual)) def test_get_thumbnail(self): self.assertTrue(self.manager.get_pixbuf(self.song, 10, 10) is None) self.assertTrue( self.manager.get_pixbuf_many([self.song], 10, 10) is None)
def setUp(self): self.manager = CoverManager()
class TCoverManager(TestCase): def setUp(self): config.init() self.manager = CoverManager() self.dir = mkdtemp() self.song = self.an_album_song() # Safety check self.failIf(glob.glob(os.path.join(self.dir + "*.jpg"))) files = [self.full_path("12345.jpg"), self.full_path("nothing.jpg")] for f in files: open(f, "w").close() def an_album_song(self, fn="asong.ogg"): return AudioFile({ "~filename": os.path.join(self.dir, fn), "album": u"Quuxly", "artist": u"Some One", }) def tearDown(self): shutil.rmtree(self.dir) config.quit() def _find_cover(self, song): return self.manager.get_cover(song) def full_path(self, path): return os.path.join(self.dir, path) def test_dir_not_exist(self): self.failIf(self._find_cover(bar_2_1)) def test_nothing(self): self.failIf(self._find_cover(self.song)) def test_labelid(self): self.song["labelid"] = "12345" assert path_equal(os.path.abspath(self._find_cover(self.song).name), self.full_path("12345.jpg")) del(self.song["labelid"]) def test_regular(self): for fn in ["cover.png", "folder.jpg", "Quuxly - front.png", "Quuxly_front_folder_cover.gif"]: f = self.add_file(fn) cover = self._find_cover(self.song) assert cover, f"No cover found after adding {fn}" assert path_equal(os.path.abspath(cover.name), f) self.test_labelid() # labelid must work with other files present def test_file_encoding(self): f = self.add_file(fsnative(u"öäü - Quuxly - cover.jpg")) self.assertTrue(isinstance(self.song("album"), str)) h = self._find_cover(self.song) assert h, "Nothing found" self.assertEqual(normalize_path(h.name), normalize_path(f)) def test_glob(self): config.set("albumart", "force_filename", str(True)) config.set("albumart", "filename", "foo.*") for fn in ["foo.jpg", "foo.png"]: f = self.add_file(fn) assert path_equal( os.path.abspath(self._find_cover(self.song).name), f) def test_invalid_glob(self): config.set("albumart", "force_filename", str(True)) config.set("albumart", "filename", "[a-2].jpg") # Should match f = self.add_file("[a-2].jpg") assert path_equal( os.path.abspath(self._find_cover(self.song).name), f) # Should not crash f = self.add_file("test.jpg") assert not path_equal( os.path.abspath(self._find_cover(self.song).name), f) def test_invalid_glob_path(self): config.set("albumart", "force_filename", str(True)) config.set("albumart", "filename", "*.jpg") # Make a dir which contains an invalid glob path = os.path.join(self.full_path("[a-2]"), "cover.jpg") mkdir(os.path.dirname(path)) f = self.add_file(path) # Change the song's path to contain the invalid glob old_song_path = self.song['~filename'] new_song_path = os.path.join(os.path.dirname(path), os.path.basename(old_song_path)) self.song['~filename'] = new_song_path # The glob in the dirname should be ignored, while the # glob in the filename/basename is honored assert path_equal( os.path.abspath(self._find_cover(self.song).name), f) self.song['~filename'] = old_song_path def test_multiple_entries(self): config.set("albumart", "force_filename", str(True)) # the order of these is important, since bar should be # preferred to both 'foo' files # the spaces after the comma and last name are intentional config.set("albumart", "filename", "bar*,foo.png, foo.jpg ") for fn in ["foo.jpg", "foo.png", "bar.jpg"]: f = self.add_file(fn) assert path_equal( os.path.abspath(self._find_cover(self.song).name), f) def test_intelligent(self): song = self.song song["artist"] = "Q-Man" song["title"] = "First Q falls hardest" fns = ["Quuxly - back.jpg", "Quuxly.jpg", "q-man - quxxly.jpg", "folder.jpeg", "Q-man - Quuxly (FRONT).jpg"] for fn in fns: f = self.add_file(fn) cover = self._find_cover(song) if cover: actual = os.path.abspath(cover.name) assert path_equal(actual, f) else: # Here, no cover is better than the back... assert path_equal(f, self.full_path("Quuxly - back.jpg")) def test_embedded_special_cover_words(self): """Tests that words incidentally containing embedded "special" words album keywords (e.g. cover, disc, back) don't trigger See Issue 818""" song = AudioFile({ "~filename": fsnative(os.path.join(self.dir, u"asong.ogg")), "album": "foobar", "title": "Ode to Baz", "artist": "Q-Man", }) data = [('back.jpg', False), ('discovery.jpg', False), ("Pharell - frontin'.jpg", False), ('nickelback - Curb.jpg', False), ('foobar.jpg', True), ('folder.jpg', True), # Though this order is debatable ('Q-Man - foobar.jpg', True), ('Q-man - foobar (cover).jpg', True)] for fn, should_find in data: f = self.add_file(fn) cover = self._find_cover(song) if cover: actual = os.path.abspath(cover.name) assert path_equal(actual, f), \ f"{basename(f)!r} should trump {basename(actual)!r}" else: self.failIf(should_find, msg="Couldn't find %s for %s" % (f, song("~filename"))) def add_file(self, fn): f = self.full_path(fn) open(f, "wb").close() return f def test_multiple_people(self): song = AudioFile({ "~filename": os.path.join(self.dir, "asong.ogg"), "album": "foobar", "title": "Ode to Baz", "performer": "The Performer", "artist": "The Composer\nThe Conductor", "composer": "The Composer", }) for fn in ["foobar.jpg", "The Performer - foobar.jpg", "The Composer - The Performer - foobar.jpg", "The Composer - The Conductor, The Performer - foobar.jpg"]: f = self.add_file(fn) cover = self._find_cover(song) self.failUnless(cover) actual = os.path.abspath(cover.name) cover.close() assert path_equal( actual, f, "\"%s\" should trump \"%s\"" % (f, actual)) def test_get_thumbnail(self): self.assertTrue(self.manager.get_pixbuf(self.song, 10, 10) is None) self.assertTrue( self.manager.get_pixbuf_many([self.song], 10, 10) is None) def test_get_many(self): songs = [AudioFile({"~filename": os.path.join(self.dir, "song.ogg"), "title": "Ode to Baz"}), self.an_album_song()] plugin = Plugin(ArtworkUrlCover) self.manager.plugin_handler.plugin_enable(plugin) self.add_file('cover.jpg') cover = self.manager.get_cover_many(songs) assert cover def test_search_missing_artist(self): titled_album_song = self.an_album_song('z.ogg') titled_album_song["artist"] = "foo" album_songs = [self.an_album_song('x.ogg'), titled_album_song, self.an_album_song()] self.manager.search_cover(Gio.Cancellable(), album_songs)
class TCoverManager(TestCase): def setUp(self): config.init() self.manager = CoverManager() self.dir = mkdtemp() self.song = self.an_album_song() # Safety check self.failIf(glob.glob(os.path.join(self.dir + "*.jpg"))) files = [self.full_path("12345.jpg"), self.full_path("nothing.jpg")] for f in files: open(f, "w").close() def an_album_song(self, fn="asong.ogg"): return AudioFile({ "~filename": os.path.join(self.dir, fn), "album": u"Quuxly", }) def tearDown(self): shutil.rmtree(self.dir) config.quit() def _find_cover(self, song): return self.manager.get_cover(song) def full_path(self, path): return os.path.join(self.dir, path) def test_dir_not_exist(self): self.failIf(self._find_cover(bar_2_1)) def test_nothing(self): self.failIf(self._find_cover(self.song)) def test_labelid(self): self.song["labelid"] = "12345" assert path_equal(os.path.abspath(self._find_cover(self.song).name), self.full_path("12345.jpg")) del(self.song["labelid"]) def test_regular(self): for fn in ["cover.png", "folder.jpg", "frontcover.jpg", "front_folder_cover.gif", "jacket_cover.front.folder.jpeg"]: f = self.add_file(fn) assert path_equal( os.path.abspath(self._find_cover(self.song).name), f) self.test_labelid() # labelid must work with other files present def test_file_encoding(self): f = self.add_file(fsnative(u"öäü - cover.jpg")) self.assertTrue(isinstance(self.song("album"), text_type)) h = self._find_cover(self.song) self.assertEqual(normalize_path(h.name), normalize_path(f)) def test_glob(self): config.set("albumart", "force_filename", str(True)) config.set("albumart", "filename", "foo.*") for fn in ["foo.jpg", "foo.png"]: f = self.add_file(fn) assert path_equal( os.path.abspath(self._find_cover(self.song).name), f) def test_invalid_glob(self): config.set("albumart", "force_filename", str(True)) config.set("albumart", "filename", "[a-2].jpg") # Should match f = self.add_file("[a-2].jpg") assert path_equal( os.path.abspath(self._find_cover(self.song).name), f) # Should not crash f = self.add_file("test.jpg") assert not path_equal( os.path.abspath(self._find_cover(self.song).name), f) def test_invalid_glob_path(self): config.set("albumart", "force_filename", str(True)) config.set("albumart", "filename", "*.jpg") # Make a dir which contains an invalid glob path = os.path.join(self.full_path("[a-2]"), "cover.jpg") mkdir(os.path.dirname(path)) f = self.add_file(path) # Change the song's path to contain the invalid glob old_song_path = self.song['~filename'] new_song_path = os.path.join(os.path.dirname(path), os.path.basename(old_song_path)) self.song['~filename'] = new_song_path # The glob in the dirname should be ignored, while the # glob in the filename/basename is honored assert path_equal( os.path.abspath(self._find_cover(self.song).name), f) self.song['~filename'] = old_song_path def test_intelligent(self): song = self.song song["artist"] = "Q-Man" song["title"] = "First Q falls hardest" fns = ["Quuxly - back.jpg", "Quuxly.jpg", "q-man - quxxly.jpg", "folder.jpeg", "Q-man - Quuxly (FRONT).jpg"] for fn in fns: f = self.add_file(fn) cover = self._find_cover(song) if cover: actual = os.path.abspath(cover.name) assert path_equal(actual, f) else: # Here, no cover is better than the back... assert path_equal(f, self.full_path("Quuxly - back.jpg")) def test_embedded_special_cover_words(self): """Tests that words incidentally containing embedded "special" words album keywords (e.g. cover, disc, back) don't trigger See Issue 818""" song = AudioFile({ "~filename": fsnative(os.path.join(self.dir, u"asong.ogg")), "album": "foobar", "title": "Ode to Baz", "artist": "Q-Man", }) data = [('back.jpg', False), ('discovery.jpg', False), ("Pharell - frontin'.jpg", False), ('nickelback - Curb.jpg', False), ('foobar.jpg', True), ('folder.jpg', True), # Though this order is debatable ('Q-Man - foobar.jpg', True), ('Q-man - foobar (cover).jpg', True)] for fn, should_find in data: f = self.add_file(fn) cover = self._find_cover(song) if cover: actual = os.path.abspath(cover.name) assert path_equal( actual, f, "\"%s\" should trump \"%s\"" % (f, actual)) else: self.failIf(should_find, msg="Couldn't find %s for %s" % (f, song("~filename"))) def add_file(self, fn): f = self.full_path(fn) open(f, "wb").close() return f def test_multiple_people(self): song = AudioFile({ "~filename": os.path.join(self.dir, "asong.ogg"), "album": "foobar", "title": "Ode to Baz", "performer": "The Performer", "artist": "The Composer\nThe Conductor", "composer": "The Composer", }) for fn in ["foobar.jpg", "The Performer - foobar.jpg", "The Composer - The Performer - foobar.jpg", "The Composer - The Conductor, The Performer - foobar.jpg"]: f = self.add_file(fn) cover = self._find_cover(song) self.failUnless(cover) actual = os.path.abspath(cover.name) cover.close() assert path_equal( actual, f, "\"%s\" should trump \"%s\"" % (f, actual)) def test_get_thumbnail(self): self.assertTrue(self.manager.get_pixbuf(self.song, 10, 10) is None) self.assertTrue( self.manager.get_pixbuf_many([self.song], 10, 10) is None) def test_get_many(self): songs = [AudioFile({"~filename": os.path.join(self.dir, "song.ogg"), "title": "Ode to Baz"}), self.an_album_song()] plugin = Plugin(ArtworkUrlCover) self.manager.plugin_handler.plugin_enable(plugin) self.add_file('cover.jpg') cover = self.manager.get_cover_many(songs) assert cover def test_search_missing_artist(self): titled_album_song = self.an_album_song('z.ogg') titled_album_song["artist"] = "foo" album_songs = [self.an_album_song('x.ogg'), titled_album_song, self.an_album_song()] self.manager.search_cover(Gio.Cancellable(), album_songs)
class TCoverManager(TestCase): def setUp(self): config.init() self.manager = CoverManager() self.dir = os.path.realpath(quux("~dirname")) # Safety check self.failIf(glob.glob(self.dir + "/*.jpg")) self.files = [self.full_path("12345.jpg"), self.full_path("nothing.jpg") ] for f in self.files: open(f, "w").close() def _find_cover(self, song): return self.manager.get_cover(song) def tearDown(self): for f in self.files: os.unlink(f) config.quit() def full_path(self, path): return os.path.join(self.dir, path) def test_dir_not_exist(self): self.failIf(self._find_cover(bar_2_1)) def test_nothing(self): self.failIf(self._find_cover(quux)) def test_labelid(self): quux["labelid"] = "12345" self.failUnlessEqual(os.path.abspath(self._find_cover(quux).name), self.full_path("12345.jpg")) del(quux["labelid"]) def test_regular(self): for fn in ["cover.png", "folder.jpg", "frontcover.jpg", "front_folder_cover.gif", "jacket_cover.front.folder.jpeg"]: f = self.add_file(fn) self.failUnlessEqual( os.path.abspath(self._find_cover(quux).name), f) self.test_labelid() # labelid must work with other files present def test_file_encoding(self): if os.name == "nt": return f = self.add_file("\xff\xff\xff\xff - cover.jpg") self.assertTrue(isinstance(quux("album"), unicode)) h = self._find_cover(quux) self.assertEqual(h.name, normalize_path(f)) def test_intelligent(self): song = quux song["artist"] = "Q-Man" song["title"] = "First Q falls hardest" fns = ["Quuxly - back.jpg", "Quuxly.jpg", "q-man - quxxly.jpg", "folder.jpeg", "Q-man - Quuxly (FRONT).jpg"] for fn in fns: f = self.add_file(fn) cover = self._find_cover(song) if cover: actual = os.path.abspath(cover.name) self.failUnlessEqual(actual, f) else: # Here, no cover is better than the back... self.failUnlessEqual(f, self.full_path("Quuxly - back.jpg")) def test_embedded_special_cover_words(self): """Tests that words incidentally containing embedded "special" words album keywords (e.g. cover, disc, back) don't trigger See Issue 818""" song = AudioFile({ "~filename": fsnative(os.path.join(self.dir, u"asong.ogg")), "album": "foobar", "title": "Ode to Baz", "artist": "Q-Man", }) data = [('back.jpg', False), ('discovery.jpg', False), ("Pharell - frontin'.jpg", False), ('nickelback - Curb.jpg', False), ('foobar.jpg', True), ('folder.jpg', True), # Though this order is debatable ('Q-Man - foobar.jpg', True), ('Q-man - foobar (cover).jpg', True)] for fn, should_find in data: f = self.add_file(fn) cover = self._find_cover(song) if cover: actual = os.path.abspath(cover.name) self.failUnlessEqual( actual, f, "\"%s\" should trump \"%s\"" % (f, actual)) else: self.failIf(should_find, msg="Couldn't find %s for %s" % (f, song("~filename"))) def add_file(self, fn): f = self.full_path(fn) open(f, "w").close() self.files.append(f) return f def test_multiple_people(self): song = AudioFile({ "~filename": fsnative(os.path.join(self.dir, u"asong.ogg")), "album": "foobar", "title": "Ode to Baz", "performer": "The Performer", "artist": "The Composer\nThe Conductor", "composer": "The Composer", }) for fn in ["foobar.jpg", "The Performer - foobar.jpg", "The Composer: The Performer - foobar.jpg", "The Composer: The Conductor, The Performer - foobar.jpg"]: f = self.add_file(fn) cover = self._find_cover(song) self.failUnless(cover) actual = os.path.abspath(cover.name) self.failUnlessEqual( actual, f, "\"%s\" should trump \"%s\"" % (f, actual)) def test_get_thumbnail(self): self.assertTrue(self.manager.get_pixbuf(quux, 10, 10) is None) self.assertTrue(self.manager.get_pixbuf_many([quux], 10, 10) is None)