supysonic/tests/managers/test_manager_user.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.user import UserManager
from supysonic.py23 import strtype

import io
import unittest
import uuid

from pony.orm import db_session, commit
from pony.orm import ObjectNotFound

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

    def tearDown(self):
        db.release_database()

    @db_session
    def create_data(self):
        # Create some users
        self.assertIsInstance(UserManager.add('alice', 'ALICE', 'test@example.com', True), db.User)
        self.assertIsInstance(UserManager.add('bob', 'BOB', 'bob@example.com', False), db.User)
        self.assertIsInstance(UserManager.add('charlie', 'CHARLIE', 'charlie@example.com', False), db.User)

        folder = db.Folder(name = 'Root', path = 'tests/assets', root = True)
        artist = db.Artist(name = 'Artist')
        album = db.Album(name = 'Album', artist = artist)
        track = db.Track(
            title = 'Track',
            disc = 1,
            number = 1,
            duration = 1,
            artist = artist,
            album = album,
            path = 'tests/assets/empty',
            folder = folder,
            root_folder = folder,
            content_type = 'audio/mpeg',
            bitrate = 320,
            last_modification = 0
        )

        playlist = db.Playlist(
            name = 'Playlist',
            user = db.User.get(name = 'alice')
        )
        playlist.add(track)

    def test_encrypt_password(self):
        func = UserManager._UserManager__encrypt_password
        self.assertEqual(func('password','salt'), ('59b3e8d637cf97edbe2384cf59cb7453dfe30789', 'salt'))
        self.assertEqual(func('pass-word','pepper'), ('d68c95a91ed7773aa57c7c044d2309a5bf1da2e7', 'pepper'))
        self.assertEqual(func(u'éèàïô', 'ABC+'), ('b639ba5217b89c906019d89d5816b407d8730898', 'ABC+'))

    @db_session
    def test_get_user(self):
        self.create_data()

        # Get existing users
        for name in ['alice', 'bob', 'charlie']:
            user = db.User.get(name = name)
            self.assertEqual(UserManager.get(user.id), user)

        # Get with invalid UUID
        self.assertRaises(ValueError, UserManager.get, 'invalid-uuid')
        self.assertRaises(ValueError, UserManager.get, 0xfee1bad)

        # Non-existent user
        self.assertRaises(ObjectNotFound, UserManager.get, uuid.uuid4())

    @db_session
    def test_add_user(self):
        self.create_data()
        self.assertEqual(db.User.select().count(), 3)

        # Create duplicate
        self.assertRaises(ValueError, UserManager.add, 'alice', 'Alic3', 'alice@example.com', True)

    @db_session
    def test_delete_user(self):
        self.create_data()

        # Delete invalid UUID
        self.assertRaises(ValueError, UserManager.delete, 'invalid-uuid')
        self.assertRaises(ValueError, UserManager.delete, 0xfee1b4d)
        self.assertEqual(db.User.select().count(), 3)

        # Delete non-existent user
        self.assertRaises(ObjectNotFound, UserManager.delete, uuid.uuid4())
        self.assertEqual(db.User.select().count(), 3)

        # Delete existing users
        for name in ['alice', 'bob', 'charlie']:
            user = db.User.get(name = name)
            UserManager.delete(user.id)
            self.assertRaises(ObjectNotFound, db.User.__getitem__, user.id)
        commit()
        self.assertEqual(db.User.select().count(), 0)

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

        # Delete existing users
        for name in ['alice', 'bob', 'charlie']:
            UserManager.delete_by_name(name)
            self.assertFalse(db.User.exists(name = name))

        # Delete non-existent user
        self.assertRaises(ObjectNotFound, UserManager.delete_by_name, 'null')

    @db_session
    def test_try_auth(self):
        self.create_data()

        # Test authentication
        for name in ['alice', 'bob', 'charlie']:
            user = db.User.get(name = name)
            authed = UserManager.try_auth(name, name.upper())
            self.assertEqual(authed, user)

        # Wrong password
        self.assertIsNone(UserManager.try_auth('alice', 'bad'))
        self.assertIsNone(UserManager.try_auth('alice', 'alice'))

        # Non-existent user
        self.assertIsNone(UserManager.try_auth('null', 'null'))

    @db_session
    def test_change_password(self):
        self.create_data()

        # With existing users
        for name in ['alice', 'bob', 'charlie']:
            user = db.User.get(name = name)
            # Good password
            UserManager.change_password(user.id, name.upper(), 'newpass')
            self.assertEqual(UserManager.try_auth(name, 'newpass'), user)
            # Old password
            self.assertEqual(UserManager.try_auth(name, name.upper()), None)
            # Wrong password
            self.assertRaises(ValueError, UserManager.change_password, user.id, 'badpass', 'newpass')

        # Ensure we still got the same number of users
        self.assertEqual(db.User.select().count(), 3)

        # With invalid UUID
        self.assertRaises(ValueError, UserManager.change_password, 'invalid-uuid', 'oldpass', 'newpass')

        # Non-existent user
        self.assertRaises(ObjectNotFound, UserManager.change_password, uuid.uuid4(), 'oldpass', 'newpass')

    @db_session
    def test_change_password2(self):
        self.create_data()

        # With existing users
        for name in ['alice', 'bob', 'charlie']:
            UserManager.change_password2(name, 'newpass')
            user = db.User.get(name = name)
            self.assertEqual(UserManager.try_auth(name, 'newpass'), user)
            self.assertEqual(UserManager.try_auth(name, name.upper()), None)

        # Non-existent user
        self.assertRaises(ObjectNotFound, UserManager.change_password2, 'null', 'newpass')

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