better tests for user commands + tests for group_api + some fixe in group_api lib

tracim/command/__init__.py

 
 from pyramid.paster import bootstrap
 from pyramid.scripting import AppEnvironment
-from tracim.exceptions import CommandAbortedError
+from tracim.exceptions import BadCommandError
 from tracim.lib.utils.utils import DEFAULT_TRACIM_CONFIG_FILE
 
 
                 with app_context['request'].tm:
                     self.take_app_action(parsed_args, app_context)
 
+
     def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
         parser = super(AppContextCommand, self).get_parser(prog_name)
 

tracim/command/user.py

 from pyramid.scripting import AppEnvironment
 import transaction
 from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm.exc import NoResultFound
 
 from tracim import CFG
 from tracim.command import AppContextCommand
 #from tracim.lib.daemons import DaemonsManager
 #from tracim.lib.daemons import RadicaleDaemon
 #from tracim.lib.email import get_email_manager
-from tracim.exceptions import AlreadyExistError
+from tracim.exceptions import UserAlreadyExistError, GroupNotExist
 from tracim.exceptions import NotificationNotSend
-from tracim.exceptions import CommandAbortedError
+from tracim.exceptions import BadCommandError
 from tracim.lib.core.group import GroupApi
 from tracim.lib.core.user import UserApi
 from tracim.models import User
         return self._user_api.user_with_email_exists(login)
 
     def _get_group(self, name: str) -> Group:
+        groups_availables = [group.group_name
+                             for group in self._group_api.get_all()]
+        if name not in groups_availables:
+            msg = "Group '{}' does not exist, choose a group name in : ".format(name)  # nopep8
+            for group in groups_availables:
+                msg+= "'{}',".format(group)
+            self._session.rollback()
+            raise GroupNotExist(msg)
         return self._group_api.get_one_with_name(name)
 
     def _add_user_to_named_group(
             user: str,
             group_name: str
     ) -> None:
+
         group = self._get_group(group_name)
         if user not in group.users:
             group.users.append(user)
     ) -> User:
         if not password:
             if self._password_required():
-                raise CommandAbortedError(
+                raise BadCommandError(
                     "You must provide -p/--password parameter"
                 )
             password = ''
             self._user_api.execute_created_user_actions(user)
         except IntegrityError:
             self._session.rollback()
-            raise AlreadyExistError()
+            raise UserAlreadyExistError()
         except NotificationNotSend as exception:
             self._session.rollback()
             raise exception
                     password=parsed_args.password,
                     do_notify=parsed_args.send_email,
                 )
-            except AlreadyExistError:
-                raise CommandAbortedError("Error: User already exist (use `user update` command instead)")
+            except UserAlreadyExistError:
+                raise UserAlreadyExistError("Error: User already exist (use `user update` command instead)")
             except NotificationNotSend:
-                raise CommandAbortedError("Error: Cannot send email notification, user not created.")
+                raise NotificationNotSend("Error: Cannot send email notification, user not created.")
             # TODO - G.M - 04-04-2018 - [Email] Check this code
             # if parsed_args.send_email:
             #     email_manager = get_email_manager()
     action = UserCommand.ACTION_UPDATE
 
 
-class LDAPUserUnknown(CommandAbortedError):
+class LDAPUserUnknown(BadCommandError):
     pass

tracim/exceptions.py

     pass
 
 
-class AlreadyExistError(TracimError):
+class UserAlreadyExistError(TracimError):
     pass
 
 
-class CommandError(TracimError):
-    pass
-
-
-class CommandAbortedError(CommandError):
+class BadCommandError(TracimError):
     pass
 
 
 
 class NotificationNotSend(TracimException):
     pass
+
+
+class GroupNotExist(TracimError):
+    pass

tracim/lib/core/group.py

 # -*- coding: utf-8 -*-
 import typing
 
+from sqlalchemy.orm.exc import NoResultFound
+
+from tracim.exceptions import GroupNotExist
+
 __author__ = 'damien'
 
 from tracim.models.auth import Group, User
         return self._session.query(Group)
 
     def get_one(self, group_id) -> Group:
-        return self._base_query().filter(Group.group_id == group_id).one()
+        try:
+            group = self._base_query().filter(Group.group_id == group_id).one()
+            return group
+        except NoResultFound:
+            raise GroupNotExist()
 
     def get_one_with_name(self, group_name) -> Group:
-        return self._base_query().filter(Group.group_name == group_name).one()
+        try:
+            group = self._base_query().filter(Group.group_name == group_name).one()
+            return group
+        except NoResultFound:
+            raise GroupNotExist()
+
+    def get_all(self):
+        return self._base_query().order_by(Group.group_id).all()

tracim/tests/commands/test_commands.py

 import tracim
 from tracim.command import TracimCLI
 from tracim.command.user import UserCommand
-from tracim.exceptions import UserNotExist
+from tracim.exceptions import UserAlreadyExistError, BadCommandError, \
+    GroupNotExist
 from tracim.lib.core.user import UserApi
 from tracim.tests import CommandFunctionalTest
 
 
     config_section = 'app:command_test'
 
-    def test_func__check_commands_list__ok__nominal_case(self):
+    def test_func__check_commands_list__ok__nominal_case(self) -> None:
         """
         Test listing of tracimcli command: Tracim commands must be listed
         :return:
         assert output.find('db delete') > 0
         assert output.find('webdav start') > 0
 
-    def test_func__user_create_command__ok__nominal_case(self):
+    def test_func__user_create_command__ok__nominal_case(self) -> None:
         """
         Test User creation
         """
             'user', 'create',
             '-c', 'tests_configs.ini#command_test',
             '-l', 'command_test@user',
-            '-p', 'new_password'
+            '-p', 'new_password',
+            '--debug',
         ])
         new_user = api.get_one_by_email('command_test@user')
         assert new_user.email == 'command_test@user'
         assert new_user.validate_password('new_password')
+        assert new_user.profile.name == 'users'
 
-    def test_func__user_update_command__ok__nominal_case(self):
+    def test_func__user_create_command__ok__in_admin_group(self) -> None:
+        """
+        Test User creation with admin as group
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        with pytest.raises(NoResultFound):
+            api.get_one_by_email('command_test@user')
+        app = TracimCLI()
+        result = app.run([
+            'user', 'create',
+            '-c', 'tests_configs.ini#command_test',
+            '-l', 'command_test@user',
+            '-p', 'new_password',
+            '-g', 'administrators',
+            '--debug',
+        ])
+        new_user = api.get_one_by_email('command_test@user')
+        assert new_user.email == 'command_test@user'
+        assert new_user.validate_password('new_password')
+        assert new_user.profile.name == 'administrators'
+
+    def test_func__user_create_command__err__in_unknown_group(self) -> None:
+        """
+        Test User creation with an unknown group
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        app = TracimCLI()
+        with pytest.raises(GroupNotExist):
+            result = app.run([
+                'user', 'create',
+                '-c', 'tests_configs.ini#command_test',
+                '-l', 'command_test@user',
+                '-p', 'new_password',
+                '-g', 'unknown',
+                '--debug',
+            ])
+
+    def test_func__user_create_command__err_user_already_exist(self) -> None:
+        """
+        Test User creation with existing user login
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        app = TracimCLI()
+        with pytest.raises(UserAlreadyExistError):
+            result = app.run([
+                '--debug',
+                'user', 'create',
+                '-c', 'tests_configs.ini#command_test',
+                '-l', 'admin@admin.admin',
+                '-p', 'new_password',
+                '--debug',
+            ])
+
+    def test_func__user_create_command__err__password_required(self) -> None:
+        """
+        Test User creation without filling password
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        app = TracimCLI()
+        with pytest.raises(BadCommandError):
+            result = app.run([
+                '--debug',
+                'user', 'create',
+                '-c', 'tests_configs.ini#command_test',
+                '-l', 'admin@admin.admin',
+                '--debug',
+            ])
+
+    def test_func__user_update_command__ok__nominal_case(self) -> None:
         """
         Test user password update
         """
             'user', 'update',
             '-c', 'tests_configs.ini#command_test',
             '-l', 'admin@admin.admin',
-            '-p', 'new_password'
+            '-p', 'new_password',
+            '--debug',
+        ])
+        new_user = api.get_one_by_email('admin@admin.admin')
+        assert new_user.email == 'admin@admin.admin'
+        assert new_user.validate_password('new_password')
+        assert not new_user.validate_password('admin@admin.admin')
+
+    def test_func__user_update_command__ok__remove_group(self) -> None:
+        """
+        Test user password update
+        """
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        user = api.get_one_by_email('admin@admin.admin')
+        assert user.email == 'admin@admin.admin'
+        assert user.validate_password('admin@admin.admin')
+        assert not user.validate_password('new_password')
+        assert user.profile.name == 'administrators'
+        app = TracimCLI()
+        result = app.run([
+            'user', 'update',
+            '-c', 'tests_configs.ini#command_test',
+            '-l', 'admin@admin.admin',
+            '-p', 'new_password',
+            '-rmg', 'administrators',
+            '--debug',
         ])
         new_user = api.get_one_by_email('admin@admin.admin')
         assert new_user.email == 'admin@admin.admin'
         assert new_user.validate_password('new_password')
         assert not new_user.validate_password('admin@admin.admin')
+        assert new_user.profile.name == 'managers'

tracim/tests/library/test_group_api.py

+# coding=utf-8
+import pytest
+
+from tracim.exceptions import GroupNotExist
+from tracim.lib.core.group import GroupApi
+from tracim.tests import DefaultTest
+from tracim.fixtures.users_and_groups import Base as BaseFixture
+from tracim.fixtures.content import Content as ContentFixture
+
+
+class TestGroupApi(DefaultTest):
+    fixtures = [BaseFixture, ContentFixture]
+
+    def test_unit__get_one__ok_nominal_case(self) -> None:
+        """
+        Get one group by id
+        """
+        api = GroupApi(
+            current_user=None,
+            session=self.session,
+        )
+        group = api.get_one(1)
+        assert group.group_id == 1
+        assert group.group_name == 'users'
+
+    def test_unit__get_one__err__group_not_exist(self) -> None:
+        """
+        Get one group who does not exist by id
+        """
+        api = GroupApi(
+            current_user=None,
+            session=self.session,
+        )
+        with pytest.raises(GroupNotExist):
+            group = api.get_one(10)
+
+    def test_unit__get_one_group_with_name__nominal_case(self) -> None:
+        """
+        get one group by name
+        """
+        api = GroupApi(
+            current_user=None,
+            session=self.session,
+        )
+        group = api.get_one_with_name('administrators')
+        assert group.group_id == 3
+        assert group.group_name == 'administrators'
+
+    def test_unit__get_one_with_name__err__group_not_exist(self) -> None:
+        """
+        get one group by name who does not exist
+        """
+        api = GroupApi(
+            current_user=None,
+            session=self.session,
+        )
+        with pytest.raises(GroupNotExist):
+            group = api.get_one_with_name('unknown_group')
+
+    def test_unit__get_all__ok__nominal_case(self):
+        """
+        get all groups
+        """
+        api = GroupApi(
+            current_user=None,
+            session=self.session,
+        )
+        groups = api.get_all()
+        assert ['users', 'managers', 'administrators'] == [group.group_name for group in groups]  # nopep8