import os

import sys

import logging

import pkg_resources

from paste.deploy import loadapp

import pylons.test

from pylons.i18n.translation import _get_translator

import pytest

from kallithea.model.user import UserModel

from kallithea.model.meta import Session

from kallithea.model.db import Setting, User, UserIpMap

from kallithea.tests.base import invalidate_all_caches, TEST_USER_REGULAR_LOGIN

def pytest_configure():

    path = os.getcwd()

    sys.path.insert(0, path)

    pkg_resources.working_set.add_entry(path)

    # Disable INFO logging of test database creation, restore with NOTSET

    logging.disable(logging.INFO)

    pylons.test.pylonsapp = loadapp('config:kallithea/tests/test.ini', relative_to=path)

    logging.disable(logging.NOTSET)

    # Initialize a translator for tests that utilize i18n

    translator = _get_translator(pylons.config.get('lang'))

    pylons.translator._push_object(translator)

    return pylons.test.pylonsapp

def create_test_user():

    """Provide users that automatically disappear after test is over."""

    test_user_ids = []

    def _create_test_user(user_form):

        user = UserModel().create(user_form)

        test_user_ids.append(user.user_id)

        return user

    yield _create_test_user

    for user_id in test_user_ids:

        UserModel().delete(user_id)

    Session().commit()

def _set_settings(*kvtseq):

    session = Session()

    for kvt in kvtseq:

        assert len(kvt) in (2, 3)

        k = kvt[0]

        v = kvt[1]

        t = kvt[2] if len(kvt) == 3 else 'unicode'

        Setting.create_or_update(k, v, t)

    session.commit()

def set_test_settings():

    """Restore settings after test is over."""

    # Save settings.

    settings_snapshot = [

        (s.app_settings_name, s.app_settings_value, s.app_settings_type)

        for s in Setting.query().all()]

    yield _set_settings

    # Restore settings.

    session = Session()

    keys = frozenset(k for (k, v, t) in settings_snapshot)

    for s in Setting.query().all():

        if s.app_settings_name not in keys:

            session.delete(s)

    for k, v, t in settings_snapshot:

        if t == 'list' and hasattr(v, '__iter__'):

            v = ','.join(v) # Quirk: must format list value manually.

        Setting.create_or_update(k, v, t)

    session.commit()

def auto_clear_ip_permissions():

    """Fixture that provides nothing but clearing IP permissions upon test

    exit. This clearing is needed to avoid other test failing to make fake http

    accesses."""

    yield

    # cleanup

    user_model = UserModel()

    user_ids = []

    user_ids.append(User.get_default_user().user_id)

    user_ids.append(User.get_by_username(TEST_USER_REGULAR_LOGIN).user_id)

    for user_id in user_ids:

        for ip in UserIpMap.query().filter(UserIpMap.user_id == user_id):

            user_model.delete_extra_ip(user_id, ip.ip_id)

    # IP permissions are cached, need to invalidate this cache explicitly

    invalidate_all_caches()

# -*- 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, ObjectDeletedError

import pytest

from kallithea.tests.base import *

from kallithea.tests.fixture import Fixture

from kallithea.tests.test_context import test_context

from kallithea.controllers.admin.users import UsersController

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

from webob.exc import HTTPNotFound

fixture = Fixture()

def user_and_repo_group_fail():

    username = 'repogrouperr'

    groupname = u'repogroup_fail'

    user = fixture.create_user(name=username)

    repo_group = fixture.create_repo_group(name=groupname, cur_user=username)

    yield user, repo_group

    # cleanup

    try:

        fixture.destroy_repo_group(repo_group)

    except ObjectDeletedError:

        # delete already succeeded in test body

        pass

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

        # TODO: Test response...

    def test_create(self):

        self.log_user()

        username = 'newtestuser'

        password = 'test12'

        password_confirmation = password

        name = u'name'

        lastname = u'lastname'

        email = 'mail@example.com'

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

            {'username': username,

             'password': password,

             'password_confirmation': password_confirmation,

             'firstname': name,

             'active': True,

             'lastname': lastname,

             'extern_name': 'internal',

             'extern_type': 'internal',

             'email': email,

             '_authentication_token': self.authentication_token()})

        # 302 Found

        # The resource was found at http://localhost/_admin/users/5/edit; you should be redirected automatically.

        self.checkSessionFlash(response, '''Created user %s''' % username)

        response = response.follow()

        response.mustcontain("""%s user settings""" % username) # in <title>

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

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

        assert new_user.username == username

        assert check_password(password, new_user.password) == True

        assert new_user.name == name

        assert new_user.lastname == lastname

        assert new_user.email == email

    def test_create_err(self):

        self.log_user()

        username = 'new_user'

        password = ''

        name = u'name'

        lastname = u'lastname'

        email = 'errmail.example.com'

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

            {'username': username,

             'password': password,

             'name': name,

             'active': False,

             'lastname': lastname,

             'email': email,

             '_authentication_token': self.authentication_token()})

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

        with pytest.raises(NoResultFound):

            get_user(), 'found user in database'

    def test_new(self):

        self.log_user()

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

    @parametrize('name,attrs',

        [('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': 'someemail@example.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(True)

        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

        params.update({'_authentication_token': self.authentication_token()})

        response = self.app.post(url('update_user', id=usr.user_id), params)

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

        params.pop('_authentication_token')

        updated_user = User.get_by_username(self.test_user_1)

        updated_params = updated_user.get_api_data(True)

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

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

        assert params == updated_params

    def test_delete(self):

        self.log_user()

        username = 'newtestuserdeleteme'

        fixture.create_user(name=username)

        new_user = Session().query(User) \

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

        response = self.app.post(url('delete_user', id=new_user.user_id),

            params={'_authentication_token': self.authentication_token()})

        self.checkSessionFlash(response, 'Successfully deleted user')

    def test_delete_repo_err(self):

        self.log_user()

        username = 'repoerr'

        reponame = u'repoerr_fail'

        fixture.create_user(name=username)

        fixture.create_repo(name=reponame, cur_user=username)

        new_user = Session().query(User) \

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

        response = self.app.post(url('delete_user', id=new_user.user_id),

            params={'_authentication_token': self.authentication_token()})

        self.checkSessionFlash(response, 'User "%s" still '

                               'owns 1 repositories and cannot be removed. '

                               'Switch owners or remove those repositories: '

                               '%s' % (username, reponame))

        response = self.app.post(url('delete_repo', repo_name=reponame),

            params={'_authentication_token': self.authentication_token()})

        self.checkSessionFlash(response, 'Deleted repository %s' % reponame)

        response = self.app.post(url('delete_user', id=new_user.user_id),

            params={'_authentication_token': self.authentication_token()})

        self.checkSessionFlash(response, 'Successfully deleted user')

    def test_delete_repo_group_err(self, user_and_repo_group_fail):

        self.log_user()

        username = 'repogrouperr'

        groupname = u'repogroup_fail'

        new_user = Session().query(User) \