def test_delete_folder(self):
with db_session:
self.create_folders()
with db_session:
# Delete invalid Folder ID
self.assertRaises(ValueError, FolderManager.delete, "invalid-uuid")
self.assertEqual(db.Folder.select().count(), 3)
# Delete non-existent folder
self.assertRaises(ObjectNotFound, FolderManager.delete, 1234567890)
self.assertEqual(db.Folder.select().count(), 3)
# Delete non-root folder
folder = db.Folder.get(name="non-root")
self.assertRaises(ObjectNotFound, FolderManager.delete, folder.id)
self.assertEqual(db.Folder.select().count(), 3)
with db_session:
# Delete existing folders
for name in ["media", "music"]:
folder = db.Folder.get(name=name, root=True)
FolderManager.delete(folder.id)
self.assertRaises(ObjectNotFound, db.Folder.__getitem__,
folder.id)
# Even if we have only 2 root folders, non-root should never exist and be cleaned anyway
self.assertEqual(db.Folder.select().count(), 0)
def test_add_folder(self):
# Added in setUp()
self.assertEqual(self.store.find(db.Folder).count(), 3)
# Create duplicate
self.assertEqual(FolderManager.add(self.store,'media', self.media_dir), FolderManager.NAME_EXISTS)
self.assertEqual(self.store.find(db.Folder, db.Folder.name == 'media').count(), 1)
# Duplicate path
self.assertEqual(FolderManager.add(self.store,'new-folder', self.media_dir), FolderManager.PATH_EXISTS)
self.assertEqual(self.store.find(db.Folder, db.Folder.path == self.media_dir).count(), 1)
# Invalid path
path = os.path.abspath('/this/not/is/valid')
self.assertEqual(FolderManager.add(self.store,'invalid-path', path), FolderManager.INVALID_PATH)
self.assertEqual(self.store.find(db.Folder, db.Folder.path == path).count(), 0)
# Subfolder of already added path
path = os.path.join(self.media_dir, 'subfolder')
os.mkdir(path)
self.assertEqual(FolderManager.add(self.store,'subfolder', path), FolderManager.PATH_EXISTS)
self.assertEqual(self.store.find(db.Folder).count(), 3)
# Parent folder of an already added path
path = os.path.join(self.media_dir, '..')
self.assertEqual(FolderManager.add(self.store, 'parent', path), FolderManager.SUBPATH_EXISTS)
self.assertEqual(self.store.find(db.Folder).count(), 3)
def create_folders(self):
# Add test folders
self.assertIsNotNone(FolderManager.add("media", self.media_dir))
self.assertIsNotNone(FolderManager.add("music", self.music_dir))
db.Folder(root=False,
name="non-root",
path=os.path.join(self.music_dir, "subfolder"))
artist = db.Artist(name="Artist")
album = db.Album(name="Album", artist=artist)
root = db.Folder.get(name="media")
db.Track(
title="Track",
artist=artist,
album=album,
disc=1,
number=1,
path=os.path.join(self.media_dir, "somefile"),
folder=root,
root_folder=root,
duration=2,
bitrate=320,
last_modification=0,
)
def test_delete_folder(self):
# Delete existing folders
for name in ['media', 'music']:
folder = self.store.find(db.Folder, db.Folder.name == name,
db.Folder.root == True).one()
self.assertEqual(FolderManager.delete(self.store, folder.id),
FolderManager.SUCCESS)
self.assertIsNone(self.store.get(db.Folder, folder.id))
# Delete invalid UUID
self.assertEqual(FolderManager.delete(self.store, 'invalid-uuid'),
FolderManager.INVALID_ID)
self.assertEqual(self.store.find(db.Folder).count(),
1) # 'non-root' remaining
# Delete non-existent folder
self.assertEqual(FolderManager.delete(self.store, uuid.uuid4()),
FolderManager.NO_SUCH_FOLDER)
self.assertEqual(self.store.find(db.Folder).count(),
1) # 'non-root' remaining
# Delete non-root folder
folder = self.store.find(db.Folder, db.Folder.name == 'non-root').one()
self.assertEqual(FolderManager.delete(self.store, folder.id),
FolderManager.NO_SUCH_FOLDER)
self.assertEqual(self.store.find(db.Folder).count(),
1) # 'non-root' remaining
def test_delete_by_name(self):
# Delete existing folders
for name in ['media', 'music']:
self.assertEqual(FolderManager.delete_by_name(self.store, name), FolderManager.SUCCESS)
self.assertEqual(self.store.find(db.Folder, db.Folder.name == name).count(), 0)
# Delete non-existent folder
self.assertEqual(FolderManager.delete_by_name(self.store, 'null'), FolderManager.NO_SUCH_FOLDER)
self.assertEqual(self.store.find(db.Folder).count(), 1) # 'non-root' remaining
def setUp(self):
super().setUp()
with db_session:
FolderManager.add("Folder", "tests/assets/folder")
scanner = Scanner()
scanner.queue_folder("Folder")
scanner.run()
self.trackid = Track.get().id
def setUp(self):
super().setUp()
with db_session:
FolderManager.add("folder", os.path.abspath("tests/assets/folder"))
scanner = Scanner()
scanner.queue_folder("folder")
scanner.run()
self.trackid = Track.select().first().id
self.userid = User.get(name="alice").id
def setUp(self):
self.store = db.get_store('sqlite:')
with io.open('schema/sqlite.sql', 'r') as f:
for statement in f.read().split(';'):
self.store.execute(statement)
FolderManager.add(self.store, 'folder', os.path.abspath('tests/assets'))
self.folder = self.store.find(db.Folder).one()
self.assertIsNotNone(self.folder)
self.scanner = Scanner(self.store)
self.scanner.scan(self.folder)
def test_get_folder(self):
# Get existing folders
for name in ['media', 'music']:
folder = self.store.find(db.Folder, db.Folder.name == name, db.Folder.root == True).one()
self.assertEqual(FolderManager.get(self.store, folder.id), (FolderManager.SUCCESS, folder))
# Get with invalid UUID
self.assertEqual(FolderManager.get(self.store, 'invalid-uuid'), (FolderManager.INVALID_ID, None))
self.assertEqual(FolderManager.get(self.store, 0xdeadbeef), (FolderManager.INVALID_ID, None))
# Non-existent folder
self.assertEqual(FolderManager.get(self.store, uuid.uuid4()), (FolderManager.NO_SUCH_FOLDER, None))
def test_delete_by_name(self):
# Delete existing folders
for name in ['media', 'music']:
self.assertEqual(FolderManager.delete_by_name(self.store, name),
FolderManager.SUCCESS)
self.assertEqual(
self.store.find(db.Folder, db.Folder.name == name).count(), 0)
# Delete non-existent folder
self.assertEqual(FolderManager.delete_by_name(self.store, 'null'),
FolderManager.NO_SUCH_FOLDER)
self.assertEqual(self.store.find(db.Folder).count(),
1) # 'non-root' remaining
def setUp(self):
self.store = db.get_store('sqlite:')
with io.open('schema/sqlite.sql', 'r') as f:
for statement in f.read().split(';'):
self.store.execute(statement)
FolderManager.add(self.store, 'folder',
os.path.abspath('tests/assets'))
self.folder = self.store.find(db.Folder).one()
self.assertIsNotNone(self.folder)
self.scanner = Scanner(self.store)
self.scanner.scan(self.folder)
def setUp(self):
# Create an empty sqlite database in memory
self.store = db.get_store("sqlite:")
# Read schema from file
with io.open('schema/sqlite.sql', 'r') as sql:
schema = sql.read()
# Create tables on memory database
for command in schema.split(';'):
self.store.execute(command)
# Create some temporary directories
self.media_dir = tempfile.mkdtemp()
self.music_dir = tempfile.mkdtemp()
# Add test folders
self.assertEqual(
FolderManager.add(self.store, 'media', self.media_dir),
FolderManager.SUCCESS)
self.assertEqual(
FolderManager.add(self.store, 'music', self.music_dir),
FolderManager.SUCCESS)
folder = db.Folder()
folder.root = False
folder.name = 'non-root'
folder.path = os.path.join(self.music_dir, 'subfolder')
self.store.add(folder)
artist = db.Artist()
artist.name = 'Artist'
album = db.Album()
album.name = 'Album'
album.artist = artist
root = self.store.find(db.Folder, db.Folder.name == 'media').one()
track = db.Track()
track.title = 'Track'
track.artist = artist
track.album = album
track.disc = 1
track.number = 1
track.path = os.path.join(self.media_dir, 'somefile')
track.folder = root
track.root_folder = root
track.duration = 2
track.content_type = 'audio/mpeg'
track.bitrate = 320
track.last_modification = 0
self.store.add(track)
self.store.commit()
def del_folder(id):
try:
idid = uuid.UUID(id)
except ValueError:
flash('Invalid folder id')
return redirect(url_for('folder_index'))
ret = FolderManager.delete(store, idid)
if ret != FolderManager.SUCCESS:
flash(FolderManager.error_str(ret))
else:
flash('Deleted folder')
return redirect(url_for('folder_index'))
def del_folder(id):
try:
idid = uuid.UUID(id)
except ValueError:
flash("Invalid folder id")
return redirect(url_for("folder_index"))
ret = FolderManager.delete(store, idid)
if ret != FolderManager.SUCCESS:
flash(FolderManager.error_str(ret))
else:
flash("Deleted folder")
return redirect(url_for("folder_index"))
def test_delete_by_name(self):
with db_session:
self.create_folders()
with db_session:
# Delete non-existent folder
self.assertRaises(ObjectNotFound, FolderManager.delete_by_name,
"null")
self.assertEqual(db.Folder.select().count(), 3)
with db_session:
# Delete existing folders
for name in ["media", "music"]:
FolderManager.delete_by_name(name)
self.assertFalse(db.Folder.exists(name=name))
def setUp(self):
# Create an empty sqlite database in memory
self.store = db.get_store("sqlite:")
# Read schema from file
with io.open('schema/sqlite.sql', 'r') as sql:
schema = sql.read()
# Create tables on memory database
for command in schema.split(';'):
self.store.execute(command)
# Create some temporary directories
self.media_dir = tempfile.mkdtemp()
self.music_dir = tempfile.mkdtemp()
# Add test folders
self.assertEqual(FolderManager.add(self.store, 'media', self.media_dir), FolderManager.SUCCESS)
self.assertEqual(FolderManager.add(self.store, 'music', self.music_dir), FolderManager.SUCCESS)
folder = db.Folder()
folder.root = False
folder.name = 'non-root'
folder.path = os.path.join(self.music_dir, 'subfolder')
self.store.add(folder)
artist = db.Artist()
artist.name = 'Artist'
album = db.Album()
album.name = 'Album'
album.artist = artist
root = self.store.find(db.Folder, db.Folder.name == 'media').one()
track = db.Track()
track.title = 'Track'
track.artist = artist
track.album = album
track.disc = 1
track.number = 1
track.path = os.path.join(self.media_dir, 'somefile')
track.folder = root
track.root_folder = root
track.duration = 2
track.content_type = 'audio/mpeg'
track.bitrate = 320
track.last_modification = 0
self.store.add(track)
self.store.commit()
def scan_folder(id = None):
s = Scanner(store)
if id is None:
for folder in store.find(Folder, Folder.root == True):
FolderManager.scan(store, folder.id, s)
else:
status = FolderManager.scan(store, id, s)
if status != FolderManager.SUCCESS:
flash(FolderManager.error_str(status))
return redirect(url_for('folder_index'))
added, deleted = s.stats()
store.commit()
flash('Added: %i artists, %i albums, %i tracks' % (added[0], added[1], added[2]))
flash('Deleted: %i artists, %i albums, %i tracks' % (deleted[0], deleted[1], deleted[2]))
return redirect(url_for('folder_index'))
def test_get_folder(self):
# Get existing folders
for name in ['media', 'music']:
folder = self.store.find(db.Folder, db.Folder.name == name,
db.Folder.root == True).one()
self.assertEqual(FolderManager.get(self.store, folder.id),
(FolderManager.SUCCESS, folder))
# Get with invalid UUID
self.assertEqual(FolderManager.get(self.store, 'invalid-uuid'),
(FolderManager.INVALID_ID, None))
self.assertEqual(FolderManager.get(self.store, 0xdeadbeef),
(FolderManager.INVALID_ID, None))
# Non-existent folder
self.assertEqual(FolderManager.get(self.store, uuid.uuid4()),
(FolderManager.NO_SUCH_FOLDER, None))
def scan_folder(id=None):
scanner = Scanner(store)
if id is None:
for folder in store.find(Folder, Folder.root == True):
scanner.scan(folder)
else:
status, folder = FolderManager.get(store, id)
if status != FolderManager.SUCCESS:
flash(FolderManager.error_str(status))
return redirect(url_for("folder_index"))
scanner.scan(folder)
scanner.finish()
added, deleted = scanner.stats()
store.commit()
flash("Added: %i artists, %i albums, %i tracks" % (added[0], added[1], added[2]))
flash("Deleted: %i artists, %i albums, %i tracks" % (deleted[0], deleted[1], deleted[2]))
return redirect(url_for("folder_index"))
def setUp(self):
db.init_database("sqlite:")
with db_session:
folder = FolderManager.add("folder",
os.path.abspath("tests/assets/folder"))
self.assertIsNotNone(folder)
self.folderid = folder.id
self.__scan()
def scan_folder(id = None):
scanner = Scanner(store)
if id is None:
for folder in store.find(Folder, Folder.root == True):
scanner.scan(folder)
else:
status, folder = FolderManager.get(store, id)
if status != FolderManager.SUCCESS:
flash(FolderManager.error_str(status))
return redirect(url_for('folder_index'))
scanner.scan(folder)
scanner.finish()
added, deleted = scanner.stats()
store.commit()
flash('Added: %i artists, %i albums, %i tracks' % (added[0], added[1], added[2]))
flash('Deleted: %i artists, %i albums, %i tracks' % (deleted[0], deleted[1], deleted[2]))
return redirect(url_for('folder_index'))
def test_delete_folder(self):
# Delete existing folders
for name in ['media', 'music']:
folder = self.store.find(db.Folder, db.Folder.name == name, db.Folder.root == True).one()
self.assertEqual(FolderManager.delete(self.store, folder.id), FolderManager.SUCCESS)
self.assertIsNone(self.store.get(db.Folder, folder.id))
# Delete invalid UUID
self.assertEqual(FolderManager.delete(self.store, 'invalid-uuid'), FolderManager.INVALID_ID)
self.assertEqual(self.store.find(db.Folder).count(), 1) # 'non-root' remaining
# Delete non-existent folder
self.assertEqual(FolderManager.delete(self.store, uuid.uuid4()), FolderManager.NO_SUCH_FOLDER)
self.assertEqual(self.store.find(db.Folder).count(), 1) # 'non-root' remaining
# Delete non-root folder
folder = self.store.find(db.Folder, db.Folder.name == 'non-root').one()
self.assertEqual(FolderManager.delete(self.store, folder.id), FolderManager.NO_SUCH_FOLDER)
self.assertEqual(self.store.find(db.Folder).count(), 1) # 'non-root' remaining
def test_human_readable_error(self):
values = [
FolderManager.SUCCESS, FolderManager.INVALID_ID,
FolderManager.NAME_EXISTS, FolderManager.INVALID_PATH,
FolderManager.PATH_EXISTS, FolderManager.NO_SUCH_FOLDER,
FolderManager.SUBPATH_EXISTS, 1594826, 'string',
uuid.uuid4()
]
for value in values:
self.assertIsInstance(FolderManager.error_str(value), basestring)
def setUp(self):
super(TranscodingTestCase, self).setUp()
self._patch_client()
with db_session:
folder = FolderManager.add("Folder", "tests/assets/folder")
scanner = Scanner()
scanner.queue_folder("Folder")
scanner.run()
self.trackid = Track.get().id
def setUp(self):
super(TranscodingTestCase, self).setUp()
self._patch_client()
with db_session:
folder = FolderManager.add('Folder', 'tests/assets/folder')
scanner = Scanner()
scanner.scan(folder)
scanner.finish()
self.trackid = Track.get().id
def setUp(self):
super(TranscodingTestCase, self).setUp()
self._patch_client()
with db_session:
folder = FolderManager.add('Folder', 'tests/assets/folder')
scanner = Scanner()
scanner.scan(folder)
scanner.finish()
self.trackid = Track.get().id
def add_folder_post():
error = False
(name, path) = map(request.form.get, ['name', 'path'])
if name in (None, ''):
flash('The name is required.')
error = True
if path in (None, ''):
flash('The path is required.')
error = True
if error:
return render_template('addfolder.html')
ret = FolderManager.add(store, name, path)
if ret != FolderManager.SUCCESS:
flash(FolderManager.error_str(ret))
return render_template('addfolder.html')
flash("Folder '%s' created. You should now run a scan" % name)
return redirect(url_for('folder_index'))
def test_add_folder(self):
# Added in setUp()
self.assertEqual(self.store.find(db.Folder).count(), 3)
# Create duplicate
self.assertEqual(
FolderManager.add(self.store, 'media', self.media_dir),
FolderManager.NAME_EXISTS)
self.assertEqual(
self.store.find(db.Folder, db.Folder.name == 'media').count(), 1)
# Duplicate path
self.assertEqual(
FolderManager.add(self.store, 'new-folder', self.media_dir),
FolderManager.PATH_EXISTS)
self.assertEqual(
self.store.find(db.Folder,
db.Folder.path == self.media_dir).count(), 1)
# Invalid path
path = os.path.abspath('/this/not/is/valid')
self.assertEqual(FolderManager.add(self.store, 'invalid-path', path),
FolderManager.INVALID_PATH)
self.assertEqual(
self.store.find(db.Folder, db.Folder.path == path).count(), 0)
# Subfolder of already added path
path = os.path.join(self.media_dir, 'subfolder')
os.mkdir(path)
self.assertEqual(FolderManager.add(self.store, 'subfolder', path),
FolderManager.PATH_EXISTS)
self.assertEqual(self.store.find(db.Folder).count(), 3)
# Parent folder of an already added path
path = os.path.join(self.media_dir, '..')
self.assertEqual(FolderManager.add(self.store, 'parent', path),
FolderManager.SUBPATH_EXISTS)
self.assertEqual(self.store.find(db.Folder).count(), 3)
def add_folder():
if request.method == 'GET':
return render_template('addfolder.html')
error = False
(name, path) = map(request.form.get, [ 'name', 'path' ])
if name in (None, ''):
flash('The name is required.')
error = True
if path in (None, ''):
flash('The path is required.')
error = True
if error:
return render_template('addfolder.html')
ret = FolderManager.add(store, name, path)
if ret != FolderManager.SUCCESS:
flash(FolderManager.error_str(ret))
return render_template('addfolder.html')
flash("Folder '%s' created. You should now run a scan" % name)
return redirect(url_for('folder_index'))
def test_get_folder(self):
self.create_folders()
# Get existing folders
for name in ["media", "music"]:
folder = db.Folder.get(name=name, root=True)
self.assertEqual(FolderManager.get(folder.id), folder)
# Get with invalid UUID
self.assertRaises(ValueError, FolderManager.get, "invalid-uuid")
self.assertRaises(ValueError, FolderManager.get, 0xDEADBEEF)
# Non-existent folder
self.assertRaises(ObjectNotFound, FolderManager.get, 1234567890)
def add_folder():
if request.method == "GET":
return render_template("addfolder.html")
error = False
(name, path) = map(request.form.get, ["name", "path"])
if name in (None, ""):
flash("The name is required.")
error = True
if path in (None, ""):
flash("The path is required.")
error = True
if error:
return render_template("addfolder.html")
ret = FolderManager.add(store, name, path)
if ret != FolderManager.SUCCESS:
flash(FolderManager.error_str(ret))
return render_template("addfolder.html")
flash("Folder '%s' created. You should now run a scan" % name)
return redirect(url_for("folder_index"))
def setUp(self):
super().setUp()
self.__dir = tempfile.mkdtemp()
with db_session:
FolderManager.add("Folder", self.__dir)
self._start()
def test_last_play(self):
with db_session:
User[self.userid].last_play = Track[self.trackid]
with db_session:
FolderManager.delete_by_name("folder")
def test_starred(self):
with db_session:
StarredTrack(user=self.userid, starred=self.trackid)
FolderManager.delete_by_name("folder")
def setUp(self):
self.__dir = tempfile.mkdtemp()
init_database("sqlite:")
with db_session:
FolderManager.add("folder", self.__dir)
def test_rating(self):
with db_session:
RatingTrack(user=self.userid, rated=self.trackid, rating=5)
FolderManager.delete_by_name("folder")
def setUp(self):
super(WatcherTestCase, self).setUp()
self.__dir = tempfile.mkdtemp()
with self._get_store() as store:
FolderManager.add(store, 'Folder', self.__dir)
self._start()
def test_human_readable_error(self):
values = [ FolderManager.SUCCESS, FolderManager.INVALID_ID, FolderManager.NAME_EXISTS,
FolderManager.INVALID_PATH, FolderManager.PATH_EXISTS, FolderManager.NO_SUCH_FOLDER,
FolderManager.SUBPATH_EXISTS, 1594826, 'string', uuid.uuid4() ]
for value in values:
self.assertIsInstance(FolderManager.error_str(value), basestring)
def setUp(self):
self.__dir = tempfile.mkdtemp()
shutil.copy("tests/assets/issue133.flac", self.__dir)
init_database("sqlite:")
with db_session:
FolderManager.add("folder", self.__dir)
