supysonic/tests/managers/test_manager_folder.py

#!/usr/bin/env python
# coding: utf-8
#
# This file is part of Supysonic.
# Supysonic is a Python implementation of the Subsonic server API.
#
# Copyright (C) 2017-2018 Alban 'spl0k' Féron
#                    2017 Óscar García Amor
#
# Distributed under terms of the GNU AGPLv3 license.

from supysonic import db
from supysonic.managers.folder import FolderManager
from supysonic.py23 import strtype

import os
import io
import shutil
import tempfile
import unittest
import uuid

from pony.orm import db_session, ObjectNotFound

class FolderManagerTestCase(unittest.TestCase):
    def setUp(self):
        # Create an empty sqlite database in memory
        db.init_database('sqlite:', True)

        # Create some temporary directories
        self.media_dir = tempfile.mkdtemp()
        self.music_dir = tempfile.mkdtemp()

    def tearDown(self):
        db.release_database()
        shutil.rmtree(self.media_dir)
        shutil.rmtree(self.music_dir)

    @db_session
    def create_folders(self):
        # Add test folders
        self.assertIsNotNone(FolderManager.add('media', self.media_dir))
        self.assertIsNotNone(FolderManager.add('music', self.music_dir))

        folder = 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')
        track = 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,
            content_type = 'audio/mpeg',
            bitrate = 320,
            last_modification = 0
        )

    @db_session
    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, uuid.uuid4())

    @db_session
    def test_add_folder(self):
        self.create_folders()
        self.assertEqual(db.Folder.select().count(), 3)

        # Create duplicate
        self.assertRaises(ValueError, FolderManager.add, 'media', self.media_dir)
        self.assertEqual(db.Folder.select(lambda f: f.name == 'media').count(), 1)

        # Duplicate path
        self.assertRaises(ValueError, FolderManager.add, 'new-folder', self.media_dir)
        self.assertEqual(db.Folder.select(lambda f: f.path == self.media_dir).count(), 1)

        # Invalid path
        path = os.path.abspath('/this/not/is/valid')
        self.assertRaises(ValueError, FolderManager.add, 'invalid-path', path)
        self.assertFalse(db.Folder.exists(path = path))

        # Subfolder of already added path
        path = os.path.join(self.media_dir, 'subfolder')
        os.mkdir(path)
        self.assertRaises(ValueError, FolderManager.add, 'subfolder', path)
        self.assertEqual(db.Folder.select().count(), 3)

        # Parent folder of an already added path
        path = os.path.join(self.media_dir, '..')
        self.assertRaises(ValueError, FolderManager.add, 'parent', path)
        self.assertEqual(db.Folder.select().count(), 3)

    @db_session
    def test_delete_folder(self):
        self.create_folders()

        # 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)

        # Delete invalid UUID
        self.assertRaises(ValueError, FolderManager.delete, 'invalid-uuid')
        self.assertEqual(db.Folder.select().count(), 1) # 'non-root' remaining

        # Delete non-existent folder
        self.assertRaises(ObjectNotFound, FolderManager.delete, uuid.uuid4())
        self.assertEqual(db.Folder.select().count(), 1) # 'non-root' remaining

        # Delete non-root folder
        folder = db.Folder.get(name = 'non-root')
        self.assertRaises(ObjectNotFound, FolderManager.delete, folder.id)
        self.assertEqual(db.Folder.select().count(), 1) # 'non-root' remaining

    @db_session
    def test_delete_by_name(self):
        self.create_folders()

        # Delete existing folders
        for name in ['media', 'music']:
            FolderManager.delete_by_name(name)
            self.assertFalse(db.Folder.exists(name = name))

        # Delete non-existent folder
        self.assertRaises(ObjectNotFound, FolderManager.delete_by_name, 'null')
        self.assertEqual(db.Folder.select().count(), 1) # 'non-root' remaining

if __name__ == '__main__':
    unittest.main()