from kallithea.lib.utils2 import safe_unicode, safe_int

from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator,\

    HasUserGroupPermissionAnyDecorator, HasPermissionAnyDecorator

from kallithea.lib.base import BaseController, render

from kallithea.model.scm import UserGroupList

from kallithea.model.user_group import UserGroupModel

from kallithea.model.repo import RepoModel

from kallithea.model.db import User, UserGroup, UserGroupToPerm,\

    UserGroupRepoToPerm, UserGroupRepoGroupToPerm

from kallithea.model.forms import UserGroupForm, UserGroupPermsForm,\

    CustomDefaultPermissionsForm

from kallithea.model.meta import Session

from kallithea.lib.utils import action_logger

from kallithea.lib.compat import json

log = logging.getLogger(__name__)

class UserGroupsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    @LoginRequired()

    def __before__(self):

        super(UserGroupsController, self).__before__()

        c.available_permissions = config['available_permissions']

    def __load_data(self, user_group_id):

        c.group_members_obj = sorted((x.user for x in c.user_group.members),

                                     key=lambda u: u.username.lower())

        c.group_members = [(x.user_id, x.username) for x in c.group_members_obj]

        c.available_members = sorted(((x.user_id, x.username) for x in

                                      User.query().all()),

                                     key=lambda u: u[1].lower())

    def __load_defaults(self, user_group_id):

        """

        Load defaults settings for edit, and update

        :param user_group_id:

        """

        user_group = UserGroup.get_or_404(user_group_id)

        data = user_group.get_dict()

        return data

    def index(self, format='html'):

        """GET /users_groups: All items in the collection"""

        # url('users_groups')

        _list = UserGroup.query()\

                        .order_by(func.lower(UserGroup.users_group_name))\

                        .all()

        group_iter = UserGroupList(_list, perm_set=['usergroup.admin'])

        user_groups_data = []

        total_records = len(group_iter)

        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

        user_group_name = lambda user_group_id, user_group_name: (

            template.get_def("user_group_name")

            .render(user_group_id, user_group_name, _=_, h=h, c=c)

        )

        user_group_actions = lambda user_group_id, user_group_name: (

            template.get_def("user_group_actions")

            .render(user_group_id, user_group_name, _=_, h=h, c=c)

        )

        for user_gr in group_iter:

            user_groups_data.append({

                "raw_name": user_gr.users_group_name,

                "group_name": user_group_name(user_gr.users_group_id,

                                              user_gr.users_group_name),

                "desc": user_gr.user_group_description,

                "members": len(user_gr.members),

                "active": h.boolicon(user_gr.users_group_active),

                "owner": h.person(user_gr.user.username),

                "action": user_group_actions(user_gr.users_group_id, user_gr.users_group_name)

            })

        c.data = json.dumps({

            "totalRecords": total_records,

            "startIndex": 0,

            "sort": None,

            "dir": "asc",

            "records": user_groups_data

        })

        return render('admin/user_groups/user_groups.html')

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

    def create(self):

        """POST /users_groups: Create a new item"""

        # url('users_groups')

        users_group_form = UserGroupForm()()

        try:

            form_result = users_group_form.to_python(dict(request.POST))

                                    description=form_result['user_group_description'],

                                    owner=self.authuser.user_id,

                                    active=form_result['users_group_active'])

            gr = form_result['users_group_name']

            action_logger(self.authuser,

                          'admin_created_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            Session().commit()

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/user_groups/user_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during creation of user group %s') \

                    % request.POST.get('users_group_name'), category='error')

        return redirect(url('users_groups'))

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

    def new(self, format='html'):

        """GET /user_groups/new: Form to create a new item"""

        # url('new_users_group')

        return render('admin/user_groups/user_group_add.html')

    @HasUserGroupPermissionAnyDecorator('usergroup.admin')

    def update(self, id):

        """PUT /user_groups/id: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('users_group', id=ID),

        #           method='put')

        # url('users_group', id=ID)

        c.user_group = UserGroup.get_or_404(id)

        c.active = 'settings'

        self.__load_data(id)

        available_members = [safe_unicode(x[0]) for x in c.available_members]

        users_group_form = UserGroupForm(edit=True,

                                         old_data=c.user_group.get_dict(),

                                         available_members=available_members)()

        try:

            form_result = users_group_form.to_python(request.POST)

            UserGroupModel().update(c.user_group, form_result)

            gr = form_result['users_group_name']

            action_logger(self.authuser,

                          'admin_updated_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            h.flash(_('Updated user group %s') % gr, category='success')

            Session().commit()

        except formencode.Invalid, errors:

            ug_model = UserGroupModel()

            defaults = errors.value

            e = errors.error_dict or {}

            defaults.update({

                'create_repo_perm': ug_model.has_perm(id,

                                                      'hg.create.repository'),

                'fork_repo_perm': ug_model.has_perm(id,

                                                    'hg.fork.repository'),

                '_method': 'put'

            })

            return htmlfill.render(

                render('admin/user_groups/user_group_edit.html'),

                defaults=defaults,

                errors=e,

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during update of user group %s') \

                    % request.POST.get('users_group_name'), category='error')

        return redirect(url('edit_users_group', id=id))

    @HasUserGroupPermissionAnyDecorator('usergroup.admin')

    def delete(self, id):

        """DELETE /user_groups/id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('users_group', id=ID),

        #           method='delete')

        # url('users_group', id=ID)

        usr_gr = UserGroup.get_or_404(id)

        try:

            UserGroupModel().delete(usr_gr)

            Session().commit()

            h.flash(_('Successfully deleted user group'), category='success')

        except UserGroupsAssignedException, e:

            h.flash(e, category='error')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of user group'),

                    category='error')

        return redirect(url('users_groups'))

from pylons.i18n.translation import _

from sqlalchemy.sql.expression import func

import kallithea

from kallithea.lib.exceptions import DefaultUserException, \

    UserOwnsReposException, UserCreationError

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    AuthUser, generate_api_key

import kallithea.lib.auth_modules.auth_internal

from kallithea.lib import auth_modules

from kallithea.lib.base import BaseController, render

from kallithea.model.api_key import ApiKeyModel

from kallithea.model.db import User, UserEmailMap, UserIpMap, UserToPerm

from kallithea.model.forms import UserForm, CustomDefaultPermissionsForm

from kallithea.model.user import UserModel

from kallithea.model.meta import Session

from kallithea.lib.utils import action_logger

from kallithea.lib.compat import json

from kallithea.lib.utils2 import datetime_to_time, safe_int

log = logging.getLogger(__name__)

class UsersController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

        super(UsersController, self).__before__()

        c.available_permissions = config['available_permissions']

        c.EXTERN_TYPE_INTERNAL = kallithea.EXTERN_TYPE_INTERNAL

    def index(self, format='html'):

        """GET /users: All items in the collection"""

        # url('users')

        c.users_list = User.query().order_by(User.username)\

                        .filter(User.username != User.DEFAULT_USER)\

                        .order_by(func.lower(User.username))\

                        .all()

        users_data = []

        total_records = len(c.users_list)

        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

        grav_tmpl = lambda user_email, size: (

                template.get_def("user_gravatar")

                .render(user_email, size, _=_, h=h, c=c))

        username = lambda user_id, username: (

                template.get_def("user_name")

                .render(user_id, username, _=_, h=h, c=c))

        user_actions = lambda user_id, username: (

                template.get_def("user_actions")

                .render(user_id, username, _=_, h=h, c=c))

        for user in c.users_list:

            users_data.append({

                "gravatar": grav_tmpl(user. email, 20),

                "raw_name": user.username,

                "username": username(user.user_id, user.username),

                "firstname": user.name,

                "lastname": user.lastname,

                "last_login": h.fmt_date(user.last_login),

                "last_login_raw": datetime_to_time(user.last_login),

                "active": h.boolicon(user.active),

                "admin": h.boolicon(user.admin),

                "extern_type": user.extern_type,

                "extern_name": user.extern_name,

                "action": user_actions(user.user_id, user.username),

            })

        c.data = json.dumps({

            "totalRecords": total_records,

            "startIndex": 0,

            "sort": None,

            "dir": "asc",

            "records": users_data

        })

        return render('admin/users/users.html')

    def create(self):

        """POST /users: Create a new item"""

        # url('users')

        c.default_extern_type = auth_modules.auth_internal.KallitheaAuthPlugin.name

        user_model = UserModel()

        user_form = UserForm()()

        try:

            form_result = user_form.to_python(dict(request.POST))

            usr = form_result['username']

            action_logger(self.authuser, 'admin_created_user:%s' % usr,

                          None, self.ip_addr, self.sa)

                    category='success')

            Session().commit()

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/users/user_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except UserCreationError, e:

            h.flash(e, 'error')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during creation of user %s') \

                    % request.POST.get('username'), category='error')

        return redirect(url('users'))

    def new(self, format='html'):

        """GET /users/new: Form to create a new item"""

        # url('new_user')

        c.default_extern_type = auth_modules.auth_internal.KallitheaAuthPlugin.name

        return render('admin/users/user_add.html')

    def update(self, id):

        """PUT /users/id: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('update_user', id=ID),

        #           method='put')

        # url('user', id=ID)

        c.active = 'profile'

        user_model = UserModel()

        c.user = user_model.get(id)

        c.extern_type = c.user.extern_type

        c.extern_name = c.user.extern_name

        c.perm_user = AuthUser(user_id=id, ip_addr=self.ip_addr)

        _form = UserForm(edit=True, old_data={'user_id': id,

                                              'email': c.user.email})()

        form_result = {}

        try:

            form_result = _form.to_python(dict(request.POST))

            skip_attrs = ['extern_type', 'extern_name']

            #TODO: plugin should define if username can be updated

            if c.extern_type != kallithea.EXTERN_TYPE_INTERNAL:

                # forbid updating username for external accounts

                skip_attrs.append('username')

            user_model.update(id, form_result, skip_attrs=skip_attrs)

            usr = form_result['username']

            action_logger(self.authuser, 'admin_updated_user:%s' % usr,

                          None, self.ip_addr, self.sa)

            h.flash(_('User updated successfully'), category='success')

            Session().commit()

        except formencode.Invalid, errors:

            defaults = errors.value

            e = errors.error_dict or {}

            defaults.update({

                'create_repo_perm': user_model.has_perm(id,

                                                        'hg.create.repository'),

                'fork_repo_perm': user_model.has_perm(id, 'hg.fork.repository'),

                '_method': 'put'

            })

            return htmlfill.render(

                render('admin/users/user_edit.html'),

                defaults=defaults,

                errors=e,

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during update of user %s') \

                    % form_result.get('username'), category='error')

        return redirect(url('edit_user', id=id))

    def delete(self, id):

        """DELETE /users/id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('delete_user', id=ID),

        #           method='delete')

        # url('user', id=ID)

        usr = User.get_or_404(id)

        try:

            UserModel().delete(usr)

            Session().commit()

            h.flash(_('Successfully deleted user'), category='success')

        except (UserOwnsReposException, DefaultUserException), e:

            h.flash(e, category='warning')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of user'),

                    category='error')

        return redirect(url('users'))

# -*- coding: utf-8 -*-

from kallithea.tests import *

from kallithea.model.db import UserGroup, UserGroupToPerm, Permission

from kallithea.model.meta import Session

TEST_USER_GROUP = 'admins_test'

class TestAdminUsersGroupsController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url('users_groups'))

        # Test response...

    def test_create(self):

        self.log_user()

        users_group_name = TEST_USER_GROUP

        response = self.app.post(url('users_groups'),

                                 {'users_group_name': users_group_name,

                                  'user_group_description': 'DESC',

                                  'active': True})

        response.follow()

        self.checkSessionFlash(response,

    def test_new(self):

        response = self.app.get(url('new_users_group'))

    def test_update(self):

        response = self.app.put(url('users_group', id=1))

    def test_update_browser_fakeout(self):

        response = self.app.post(url('users_group', id=1),

                                 params=dict(_method='put'))

    def test_delete(self):

        self.log_user()

        users_group_name = TEST_USER_GROUP + 'another'

        response = self.app.post(url('users_groups'),

                                 {'users_group_name':users_group_name,

                                  'user_group_description': 'DESC',

                                  'active': True})

        response.follow()

        self.checkSessionFlash(response,

        gr = Session().query(UserGroup)\

            .filter(UserGroup.users_group_name == users_group_name).one()

        response = self.app.delete(url('users_group', id=gr.users_group_id))

        gr = Session().query(UserGroup)\

            .filter(UserGroup.users_group_name == users_group_name).scalar()

        self.assertEqual(gr, None)

    def test_default_perms_enable_repository_read_on_group(self):

        self.log_user()

        users_group_name = TEST_USER_GROUP + 'another2'

        response = self.app.post(url('users_groups'),

                                 {'users_group_name': users_group_name,

                                  'user_group_description': 'DESC',

                                  'active': True})

        response.follow()

        ug = UserGroup.get_by_group_name(users_group_name)

        self.checkSessionFlash(response,

        ## ENABLE REPO CREATE ON A GROUP

        response = self.app.put(url('edit_user_group_default_perms',

                                    id=ug.users_group_id),

                                 {'create_repo_perm': True})

        response.follow()

        ug = UserGroup.get_by_group_name(users_group_name)

        p = Permission.get_by_key('hg.create.repository')

        p2 = Permission.get_by_key('hg.usergroup.create.false')

        p3 = Permission.get_by_key('hg.fork.none')

        # check if user has this perms, they should be here since

        # defaults are on

        perms = UserGroupToPerm.query()\

            .filter(UserGroupToPerm.users_group == ug).all()

        self.assertEqual(

            sorted([[x.users_group_id, x.permission_id, ] for x in perms]),

            sorted([[ug.users_group_id, p.permission_id],

                    [ug.users_group_id, p2.permission_id],

                    [ug.users_group_id, p3.permission_id]]))

        ## DISABLE REPO CREATE ON A GROUP

        response = self.app.put(

            url('edit_user_group_default_perms', id=ug.users_group_id), {})

        response.follow()

        ug = UserGroup.get_by_group_name(users_group_name)

        p = Permission.get_by_key('hg.create.none')

        p2 = Permission.get_by_key('hg.usergroup.create.false')

        p3 = Permission.get_by_key('hg.fork.none')

        # check if user has this perms, they should be here since

        # defaults are on

        perms = UserGroupToPerm.query()\

            .filter(UserGroupToPerm.users_group == ug).all()

        self.assertEqual(

            sorted([[x.users_group_id, x.permission_id, ] for x in perms]),

            sorted([[ug.users_group_id, p.permission_id],

                    [ug.users_group_id, p2.permission_id],

                    [ug.users_group_id, p3.permission_id]]))

        # DELETE !

        ug = UserGroup.get_by_group_name(users_group_name)

        ugid = ug.users_group_id

        response = self.app.delete(url('users_group', id=ug.users_group_id))

        response = response.follow()

        gr = Session().query(UserGroup)\

            .filter(UserGroup.users_group_name == users_group_name).scalar()

        self.assertEqual(gr, None)

        p = Permission.get_by_key('hg.create.repository')

        perms = UserGroupToPerm.query()\

            .filter(UserGroupToPerm.users_group_id == ugid).all()

        perms = [[x.users_group_id,

                  x.permission_id, ] for x in perms]

        self.assertEqual(perms, [])

    def test_default_perms_enable_repository_fork_on_group(self):

        self.log_user()

        users_group_name = TEST_USER_GROUP + 'another2'

        response = self.app.post(url('users_groups'),

                                 {'users_group_name': users_group_name,

                                  'user_group_description': 'DESC',

                                  'active': True})

        response.follow()

        ug = UserGroup.get_by_group_name(users_group_name)

        self.checkSessionFlash(response,

        ## ENABLE REPO CREATE ON A GROUP

        response = self.app.put(url('edit_user_group_default_perms',

                                    id=ug.users_group_id),

                                {'fork_repo_perm': True})

        response.follow()

        ug = UserGroup.get_by_group_name(users_group_name)

        p = Permission.get_by_key('hg.create.none')

        p2 = Permission.get_by_key('hg.usergroup.create.false')

        p3 = Permission.get_by_key('hg.fork.repository')

        # check if user has this perms, they should be here since

        # defaults are on

        perms = UserGroupToPerm.query()\

            .filter(UserGroupToPerm.users_group == ug).all()

        self.assertEqual(

            sorted([[x.users_group_id, x.permission_id, ] for x in perms]),

            sorted([[ug.users_group_id, p.permission_id],

                    [ug.users_group_id, p2.permission_id],

                    [ug.users_group_id, p3.permission_id]]))

        ## DISABLE REPO CREATE ON A GROUP

        response = self.app.put(

            url('edit_user_group_default_perms', id=ug.users_group_id), {})

        response.follow()

        ug = UserGroup.get_by_group_name(users_group_name)

        p = Permission.get_by_key('hg.create.none')

        p2 = Permission.get_by_key('hg.usergroup.create.false')

        p3 = Permission.get_by_key('hg.fork.none')

        # check if user has this perms, they should be here since

        # defaults are on

        perms = UserGroupToPerm.query()\

            .filter(UserGroupToPerm.users_group == ug).all()

        self.assertEqual(

            sorted([[x.users_group_id, x.permission_id, ] for x in perms]),

            sorted([[ug.users_group_id, p.permission_id],

                    [ug.users_group_id, p2.permission_id],

                    [ug.users_group_id, p3.permission_id]]))

        # DELETE !

        ug = UserGroup.get_by_group_name(users_group_name)

        ugid = ug.users_group_id

        response = self.app.delete(url('users_group', id=ug.users_group_id))

        response = response.follow()

        gr = Session().query(UserGroup)\

                           .filter(UserGroup.users_group_name ==

                                   users_group_name).scalar()

        self.assertEqual(gr, None)

        p = Permission.get_by_key('hg.fork.repository')

        perms = UserGroupToPerm.query()\

            .filter(UserGroupToPerm.users_group_id == ugid).all()

        perms = [[x.users_group_id,

                  x.permission_id, ] for x in perms]

        self.assertEqual(

            perms,

            []

        )

    def test_delete_browser_fakeout(self):

        response = self.app.post(url('users_group', id=1),

                                 params=dict(_method='delete'))

    def test_show(self):

        response = self.app.get(url('users_group', id=1))

    def test_edit(self):

        response = self.app.get(url('edit_users_group', id=1))

    def test_assign_members(self):

        pass

    def test_add_create_permission(self):

        pass

    def test_revoke_members(self):

        pass

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from sqlalchemy.orm.exc import NoResultFound

from kallithea.tests import *

from kallithea.tests.fixture import Fixture

from kallithea.model.db import User, Permission, UserIpMap, UserApiKeys

from kallithea.lib.auth import check_password

from kallithea.model.user import UserModel

from kallithea.model import validators

from kallithea.lib import helpers as h

from kallithea.model.meta import Session

fixture = Fixture()

class TestAdminUsersController(TestController):

    test_user_1 = 'testme'

    @classmethod

    def teardown_class(cls):

        if User.get_by_username(cls.test_user_1):

            UserModel().delete(cls.test_user_1)

            Session().commit()

    def test_index(self):

        self.log_user()

        response = self.app.get(url('users'))

        # Test response...

    def test_create(self):

        self.log_user()

        username = 'newtestuser'

        password = 'test12'

        password_confirmation = password

        name = 'name'

        lastname = 'lastname'

        email = 'mail@mail.com'

        response = self.app.post(url('users'),

            {'username': username,

             'password': password,

             'password_confirmation': password_confirmation,

             'firstname': name,

             'active': True,

             'lastname': lastname,

             'extern_name': 'internal',

             'extern_type': 'internal',

             'email': email})

        new_user = Session().query(User).\

            filter(User.username == username).one()

        self.assertEqual(new_user.username, username)

        self.assertEqual(check_password(password, new_user.password), True)

        self.assertEqual(new_user.name, name)

        self.assertEqual(new_user.lastname, lastname)

        self.assertEqual(new_user.email, email)

        response.follow()

        response = response.follow()

        response.mustcontain("""newtestuser""")

    def test_create_err(self):

        self.log_user()

        username = 'new_user'

        password = ''

        name = 'name'

        lastname = 'lastname'

        email = 'errmail.com'

        response = self.app.post(url('users'), {'username': username,

                                               'password': password,

                                               'name': name,

                                               'active': False,

                                               'lastname': lastname,

                                               'email': email})

        msg = validators.ValidUsername(False, {})._messages['system_invalid_username']

        msg = h.html_escape(msg % {'username': 'new_user'})

        response.mustcontain("""<span class="error-message">%s</span>""" % msg)

        response.mustcontain("""<span class="error-message">Please enter a value</span>""")

        response.mustcontain("""<span class="error-message">An email address must contain a single @</span>""")

        def get_user():

            Session().query(User).filter(User.username == username).one()

        self.assertRaises(NoResultFound, get_user), 'found user in database'

    def test_new(self):

        self.log_user()

        response = self.app.get(url('new_user'))

    @parameterized.expand(

        [('firstname', {'firstname': 'new_username'}),

         ('lastname', {'lastname': 'new_username'}),

         ('admin', {'admin': True}),

         ('admin', {'admin': False}),

         ('extern_type', {'extern_type': 'ldap'}),

         ('extern_type', {'extern_type': None}),

         ('extern_name', {'extern_name': 'test'}),

         ('extern_name', {'extern_name': None}),

         ('active', {'active': False}),

         ('active', {'active': True}),

         ('email', {'email': 'some@email.com'}),

        # ('new_password', {'new_password': 'foobar123',

        #                   'password_confirmation': 'foobar123'})

        ])

    def test_update(self, name, attrs):

        self.log_user()

        usr = fixture.create_user(self.test_user_1, password='qweqwe',

                                  email='testme@example.com',

                                  extern_type='internal',

                                  extern_name=self.test_user_1,

                                  skip_if_exists=True)

        Session().commit()

        params = usr.get_api_data()

        params.update({'password_confirmation': ''})

        params.update({'new_password': ''})

        params.update(attrs)

        if name == 'email':

            params['emails'] = [attrs['email']]

        if name == 'extern_type':

            #cannot update this via form, expected value is original one

            params['extern_type'] = "internal"

        if name == 'extern_name':

            #cannot update this via form, expected value is original one

            params['extern_name'] = self.test_user_1

            # special case since this user is not

                                          # logged in yet his data is not filled

                                          # so we use creation data

        response = self.app.put(url('user', id=usr.user_id), params)

        self.checkSessionFlash(response, 'User updated successfully')

        updated_user = User.get_by_username(self.test_user_1)

        updated_params = updated_user.get_api_data()

        updated_params.update({'password_confirmation': ''})

        updated_params.update({'new_password': ''})

        self.assertEqual(params, updated_params)

    def test_delete(self):

        self.log_user()

        username = 'newtestuserdeleteme'