mirror of
https://github.com/beetbox/beets.git
synced 2025-12-11 02:53:58 +01:00
ed51369dce
current metadata to be correct if it's complete Previously, we were using the Munkres algorithm (minimum bipartite matching) to order tracks intelligently only as a fallback if the current metadata was paradoxical or incomplete. This was because of a concern about the performance of the potentially-O(n^3) Munkres solver. However, it was found that (a) the performance is actually not bad, taking on the order of 0.02 to perform a matching, and (b) there was no recourse for the tagger to reorder tracks that were legitimately in the wrong order. Now, we get intelligent reordering of badly tagged music even when the metadata seems to be complete. To retain some of the functionality of the old orderer, the track distance metric was expanded to include a component reflecting the track index. In doing this, another bug was discovered in the UI that showed the track name differences based on an arbitrary ordering. Now, the tag_album function returns a reordered items list with every candidate.
214 lines
7.2 KiB
Python
214 lines
7.2 KiB
Python
# This file is part of beets.
|
|
# Copyright 2010, Adrian Sampson.
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining
|
|
# a copy of this software and associated documentation files (the
|
|
# "Software"), to deal in the Software without restriction, including
|
|
# without limitation the rights to use, copy, modify, merge, publish,
|
|
# distribute, sublicense, and/or sell copies of the Software, and to
|
|
# permit persons to whom the Software is furnished to do so, subject to
|
|
# the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be
|
|
# included in all copies or substantial portions of the Software.
|
|
|
|
"""Tests for non-query database functions of Item.
|
|
"""
|
|
|
|
import unittest, sys, os
|
|
sys.path.append('..')
|
|
import beets.library
|
|
|
|
def lib(): return beets.library.Library('rsrc' + os.sep + 'test.blb')
|
|
def boracay(l): return beets.library.Item(l.conn.execute('select * from items '
|
|
'where id=3').fetchone())
|
|
def item(): return beets.library.Item({
|
|
'title': u'the title',
|
|
'artist': u'the artist',
|
|
'album': u'the album',
|
|
'genre': u'the genre',
|
|
'composer': u'the composer',
|
|
'grouping': u'the grouping',
|
|
'year': 1,
|
|
'month': 2,
|
|
'day': 3,
|
|
'track': 4,
|
|
'tracktotal': 5,
|
|
'disc': 6,
|
|
'disctotal': 7,
|
|
'lyrics': u'the lyrics',
|
|
'comments': u'the comments',
|
|
'bpm': 8,
|
|
'comp': True,
|
|
'path': 'somepath',
|
|
'length': 60.0,
|
|
'bitrate': 128000,
|
|
})
|
|
np = beets.library._normpath
|
|
|
|
class LoadTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.lib = lib()
|
|
self.i = boracay(self.lib)
|
|
def tearDown(self):
|
|
self.lib.conn.close()
|
|
|
|
def test_load_restores_data_from_db(self):
|
|
original_title = self.i.title
|
|
self.i.title = 'something'
|
|
self.lib.load(self.i)
|
|
self.assertEqual(original_title, self.i.title)
|
|
|
|
def test_load_clears_dirty_flags(self):
|
|
self.i.artist = 'something'
|
|
self.lib.load(self.i)
|
|
self.assertTrue(not self.i.dirty['artist'])
|
|
|
|
class StoreTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.lib = lib()
|
|
self.i = boracay(self.lib)
|
|
def tearDown(self):
|
|
self.lib.conn.close()
|
|
|
|
def test_store_changes_database_value(self):
|
|
self.i.year = 1987
|
|
self.lib.store(self.i)
|
|
new_year = self.lib.conn.execute('select year from items where '
|
|
'title="Boracay"').fetchone()['year']
|
|
self.assertEqual(new_year, 1987)
|
|
|
|
def test_store_only_writes_dirty_fields(self):
|
|
original_genre = self.i.genre
|
|
self.i.record['genre'] = 'beatboxing' # change value w/o dirtying
|
|
self.lib.store(self.i)
|
|
new_genre = self.lib.conn.execute('select genre from items where '
|
|
'title="Boracay"').fetchone()['genre']
|
|
self.assertEqual(new_genre, original_genre)
|
|
|
|
def test_store_clears_dirty_flags(self):
|
|
self.i.composer = 'tvp'
|
|
self.lib.store(self.i)
|
|
self.assertTrue(not self.i.dirty['composer'])
|
|
|
|
class AddTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.lib = beets.library.Library(':memory:')
|
|
self.i = item()
|
|
def tearDown(self):
|
|
self.lib.conn.close()
|
|
|
|
def test_item_add_inserts_row(self):
|
|
self.lib.add(self.i)
|
|
new_grouping = self.lib.conn.execute('select grouping from items '
|
|
'where composer="the composer"').fetchone()['grouping']
|
|
self.assertEqual(new_grouping, self.i.grouping)
|
|
|
|
def test_library_add_path_inserts_row(self):
|
|
self.lib.add_path(os.path.join('rsrc', 'full.mp3'))
|
|
new_grouping = self.lib.conn.execute('select grouping from items '
|
|
'where composer="the composer"').fetchone()['grouping']
|
|
self.assertEqual(new_grouping, self.i.grouping)
|
|
|
|
|
|
class RemoveTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.lib = lib()
|
|
self.i = boracay(self.lib)
|
|
def tearDown(self):
|
|
self.lib.conn.close()
|
|
|
|
def test_remove_deletes_from_db(self):
|
|
self.lib.remove(self.i)
|
|
c = self.lib.conn.execute('select * from items where id=3')
|
|
self.assertEqual(c.fetchone(), None)
|
|
|
|
class GetSetTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.i = item()
|
|
|
|
def test_set_changes_value(self):
|
|
self.i.bpm = 4915
|
|
self.assertEqual(self.i.bpm, 4915)
|
|
|
|
def test_set_sets_dirty_flag(self):
|
|
self.i.comp = not self.i.comp
|
|
self.assertTrue(self.i.dirty['comp'])
|
|
|
|
def test_set_does_not_dirty_if_value_unchanged(self):
|
|
self.i.title = self.i.title
|
|
self.assertTrue(not self.i.dirty['title'])
|
|
|
|
def test_invalid_field_raises_attributeerror(self):
|
|
self.assertRaises(AttributeError, getattr, self.i, 'xyzzy')
|
|
|
|
class DestinationTest(unittest.TestCase):
|
|
def setUp(self):
|
|
self.lib = beets.library.Library(':memory:')
|
|
self.i = item()
|
|
def tearDown(self):
|
|
self.lib.conn.close()
|
|
|
|
def test_directory_works_with_trailing_slash(self):
|
|
self.lib.directory = 'one/'
|
|
self.lib.path_format = 'two'
|
|
self.assertEqual(self.lib.destination(self.i), np('one/two'))
|
|
|
|
def test_directory_works_without_trailing_slash(self):
|
|
self.lib.directory = 'one'
|
|
self.lib.path_format = 'two'
|
|
self.assertEqual(self.lib.destination(self.i), np('one/two'))
|
|
|
|
def test_destination_substitues_metadata_values(self):
|
|
self.lib.directory = 'base'
|
|
self.lib.path_format = '$album/$artist $title'
|
|
self.i.title = 'three'
|
|
self.i.artist = 'two'
|
|
self.i.album = 'one'
|
|
self.assertEqual(self.lib.destination(self.i),
|
|
np('base/one/two three'))
|
|
|
|
def test_destination_preserves_extension(self):
|
|
self.lib.directory = 'base'
|
|
self.lib.path_format = '$title'
|
|
self.i.path = 'hey.audioFormat'
|
|
self.assertEqual(self.lib.destination(self.i),
|
|
np('base/the title.audioFormat'))
|
|
|
|
def test_destination_pads_some_indices(self):
|
|
self.lib.directory = 'base'
|
|
self.lib.path_format = '$track $tracktotal ' \
|
|
'$disc $disctotal $bpm $year'
|
|
self.i.track = 1
|
|
self.i.tracktotal = 2
|
|
self.i.disc = 3
|
|
self.i.disctotal = 4
|
|
self.i.bpm = 5
|
|
self.i.year = 6
|
|
self.assertEqual(self.lib.destination(self.i),
|
|
np('base/01 02 03 04 5 6'))
|
|
|
|
def test_destination_escapes_slashes(self):
|
|
self.i.album = 'one/two'
|
|
dest = self.lib.destination(self.i)
|
|
self.assertTrue('one' in dest)
|
|
self.assertTrue('two' in dest)
|
|
self.assertFalse('one/two' in dest)
|
|
|
|
def test_destination_long_names_truncated(self):
|
|
self.i.title = 'X'*300
|
|
self.i.artist = 'Y'*300
|
|
for c in self.lib.destination(self.i).split(os.path.sep):
|
|
self.assertTrue(len(c) <= 255)
|
|
|
|
def test_destination_long_names_keep_extension(self):
|
|
self.i.title = 'X'*300
|
|
self.i.path = 'something.extn'
|
|
dest = self.lib.destination(self.i)
|
|
self.assertEqual(dest[-5:], '.extn')
|
|
|
|
def suite():
|
|
return unittest.TestLoader().loadTestsFromName(__name__)
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main(defaultTest='suite')
|