# -*- 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/>.

"""

Pylons application test package

This package assumes the Pylons environment is already loaded.

This module initializes the application via ``websetup`` (`paster

setup-app`) and provides the base testing objects.

Refer to docs/contributing.rst for details on running the test suite.

"""

import os

import re

import time

import logging

import datetime

import hashlib

import tempfile

from os.path import join as jn

from tempfile import _RandomNameSequence

import pylons

import pylons.test

from pylons import config, url

from pylons.i18n.translation import _get_translator

from pylons.util import ContextObj

from routes.util import URLGenerator

from webtest import TestApp

import pytest

from kallithea.lib.compat import unittest

from kallithea import is_windows

from kallithea.model.db import Notification, User, UserNotification

from kallithea.model.meta import Session

from kallithea.tests.parameterized import parameterized

from kallithea.lib.utils2 import safe_str

os.environ['TZ'] = 'UTC'

if not is_windows:

    time.tzset()

log = logging.getLogger(__name__)

skipif = pytest.mark.skipif

parametrize = pytest.mark.parametrize

__all__ = [

    'skipif', 'parametrize', 'parameterized', 'environ', 'url', 'TestController', 'TestControllerPytest',

    'ldap_lib_installed', 'pam_lib_installed', 'BaseTestCase', 'init_stack',

    'TESTS_TMP_PATH', 'HG_REPO', 'GIT_REPO', 'NEW_HG_REPO', 'NEW_GIT_REPO',

    'HG_FORK', 'GIT_FORK', 'TEST_USER_ADMIN_LOGIN', 'TEST_USER_ADMIN_PASS',

    'TEST_USER_ADMIN_EMAIL', 'TEST_USER_REGULAR_LOGIN', 'TEST_USER_REGULAR_PASS',

    'TEST_USER_REGULAR_EMAIL', 'TEST_USER_REGULAR2_LOGIN',

    'TEST_USER_REGULAR2_PASS', 'TEST_USER_REGULAR2_EMAIL', 'TEST_HG_REPO',

    'TEST_HG_REPO_CLONE', 'TEST_HG_REPO_PULL', 'TEST_GIT_REPO',

    'TEST_GIT_REPO_CLONE', 'TEST_GIT_REPO_PULL', 'HG_REMOTE_REPO',

    'GIT_REMOTE_REPO', 'SCM_TESTS', 'remove_all_notifications',

]

# Invoke websetup with the current config file

# SetupCommand('setup-app').run([config_file])

environ = {}

#SOME GLOBALS FOR TESTS

TESTS_TMP_PATH = jn('/', 'tmp', 'rc_test_%s' % _RandomNameSequence().next())

TEST_USER_ADMIN_LOGIN = 'test_admin'

TEST_USER_ADMIN_PASS = 'test12'

TEST_USER_ADMIN_EMAIL = 'test_admin@example.com'

TEST_USER_REGULAR_LOGIN = 'test_regular'

TEST_USER_REGULAR_PASS = 'test12'

TEST_USER_REGULAR_EMAIL = 'test_regular@example.com'

TEST_USER_REGULAR2_LOGIN = 'test_regular2'

TEST_USER_REGULAR2_PASS = 'test12'

TEST_USER_REGULAR2_EMAIL = 'test_regular2@example.com'

HG_REPO = u'vcs_test_hg'

GIT_REPO = u'vcs_test_git'

NEW_HG_REPO = u'vcs_test_hg_new'

NEW_GIT_REPO = u'vcs_test_git_new'

HG_FORK = u'vcs_test_hg_fork'

GIT_FORK = u'vcs_test_git_fork'

## VCS

SCM_TESTS = ['hg', 'git']

uniq_suffix = str(int(time.mktime(datetime.datetime.now().timetuple())))

GIT_REMOTE_REPO = 'git://github.com/codeinn/vcs.git'

TEST_GIT_REPO = jn(TESTS_TMP_PATH, GIT_REPO)

TEST_GIT_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcsgitclone%s' % uniq_suffix)

TEST_GIT_REPO_PULL = jn(TESTS_TMP_PATH, 'vcsgitpull%s' % uniq_suffix)

HG_REMOTE_REPO = 'http://bitbucket.org/marcinkuzminski/vcs'

TEST_HG_REPO = jn(TESTS_TMP_PATH, HG_REPO)

TEST_HG_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcshgclone%s' % uniq_suffix)

TEST_HG_REPO_PULL = jn(TESTS_TMP_PATH, 'vcshgpull%s' % uniq_suffix)

TEST_DIR = tempfile.gettempdir()

TEST_REPO_PREFIX = 'vcs-test'

# cached repos if any !

# comment out to get some other repos from bb or github

GIT_REMOTE_REPO = jn(TESTS_TMP_PATH, GIT_REPO)

HG_REMOTE_REPO = jn(TESTS_TMP_PATH, HG_REPO)

#skip ldap tests if LDAP lib is not installed

ldap_lib_installed = False

try:

    import ldap

    ldap.API_VERSION

    ldap_lib_installed = True

except ImportError:

    # means that python-ldap is not installed

    pass

try:

    import pam

    pam.PAM_TEXT_INFO

    pam_lib_installed = True

except ImportError:

    pam_lib_installed = False

class NullHandler(logging.Handler):

    def emit(self, record):

        pass

def init_stack(config=None):

    if not config:

        config = pylons.test.pylonsapp.config

    url._push_object(URLGenerator(config['routes.map'], environ))

    pylons.app_globals._push_object(config['pylons.app_globals'])

    pylons.config._push_object(config)

    pylons.tmpl_context._push_object(ContextObj())

    # Initialize a translator for tests that utilize i18n

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

    pylons.translator._push_object(translator)

    h = NullHandler()

    logging.getLogger("kallithea").addHandler(h)

def remove_all_notifications():

    Notification.query().delete()

    # Because query().delete() does not (by default) trigger cascades.

    # http://docs.sqlalchemy.org/en/rel_0_7/orm/collections.html#passive-deletes

    UserNotification.query().delete()

    Session().commit()

class BaseTestCase(unittest.TestCase):

    """Unittest-style base test case. Deprecated in favor of pytest style."""

    def __init__(self, *args, **kwargs):

        self.wsgiapp = pylons.test.pylonsapp

        init_stack(self.wsgiapp.config)

        unittest.TestCase.__init__(self, *args, **kwargs)

class BaseTestController(object):

    """Base test controller used by pytest and unittest tests controllers."""

    # Note: pytest base classes cannot have an __init__ method

    def init(self):

        self.app = TestApp(self.wsgiapp)

        self.maxDiff = None

        self.index_location = config['app_conf']['index_dir']

    def log_user(self, username=TEST_USER_ADMIN_LOGIN,

                 password=TEST_USER_ADMIN_PASS):

        self._logged_username = username

        response = self.app.post(url(controller='login', action='index'),

                                 {'username': username,

                                  'password': password})

        if 'Invalid username or password' in response.body:

        self.assertEqual(response.status, '302 Found')

        self.assert_authenticated_user(response, username)

        response = response.follow()

        return response.session['authuser']

    def _get_logged_user(self):

        return User.get_by_username(self._logged_username)

    def assert_authenticated_user(self, response, expected_username):

        cookie = response.session.get('authuser')

        user = cookie and cookie.get('user_id')

        user = user and User.get(user)

        user = user and user.username

        self.assertEqual(user, expected_username)

    def authentication_token(self):

        return self.app.get(url('authentication_token')).body

    def checkSessionFlash(self, response, msg=None, skip=0, _matcher=lambda msg, m: msg in m):

        if 'flash' not in response.session:

        try:

            level, m = response.session['flash'][-1 - skip]

            if _matcher(msg, m):

                return

        except IndexError:

            pass

                           (msg, skip,

                            ', '.join('`%s`' % m for level, m in response.session['flash']))))

    def checkSessionFlashRegex(self, response, regex, skip=0):

        self.checkSessionFlash(response, regex, skip=skip, _matcher=re.search)

class TestController(BaseTestCase, BaseTestController):

    """Deprecated unittest-style test controller"""

    def __init__(self, *args, **kwargs):

        super(TestController, self).__init__(*args, **kwargs)

        self.init()

class TestControllerPytest(BaseTestController):

    """Pytest-style test controller"""

    # Note: pytest base classes cannot have an __init__ method

    @pytest.fixture(autouse=True)

    def app_fixture(self):

        self.wsgiapp = pylons.test.pylonsapp

        init_stack(self.wsgiapp.config)

        self.init()

        return self.app

    # transitional implementations of unittest.TestCase asserts

    # Users of these should be converted to pytest's single 'assert' call

    def assertEqual(self, first, second, msg=None):

        assert first == second

    def assertNotEqual(self, first, second, msg=None):

        assert first != second

    def assertTrue(self, expr, msg=None):

        assert bool(expr) is True

    def assertFalse(self, expr, msg=None):

        assert bool(expr) is False

    def assertIn(self, first, second, msg=None):

        assert first in second

    def assertNotIn(self, first, second, msg=None):

        assert first not in second

    def assertSetEqual(self, first, second, msg=None):

        assert first == second

    def assertListEqual(self, first, second, msg=None):

        assert first == second

    def assertDictEqual(self, first, second, msg=None):

        assert first == second

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

import os

import mock

import urllib

from kallithea.lib import vcs

from kallithea.lib.utils2 import safe_str, safe_unicode

from kallithea.model.db import Repository, RepoGroup, UserRepoToPerm, User, \

    Permission

from kallithea.model.user import UserModel

from kallithea.tests import *

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.repo import RepoModel

from kallithea.model.meta import Session

from kallithea.tests.fixture import Fixture, error_function

fixture = Fixture()

def _get_permission_for_user(user, repo):

    perm = UserRepoToPerm.query() \

                .filter(UserRepoToPerm.repository ==

                        Repository.get_by_repo_name(repo)) \

                .filter(UserRepoToPerm.user == User.get_by_username(user)) \

                .all()

    return perm

class _BaseTest(object):

    """

    Write all tests here

    """

    REPO = None

    REPO_TYPE = None

    NEW_REPO = None

    OTHER_TYPE_REPO = None

    OTHER_TYPE = None

    @classmethod

    def setup_class(cls):

        pass

    @classmethod

    def teardown_class(cls):

        pass

    def test_index(self):

        self.log_user()

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

    def test_create(self):

        self.log_user()

        repo_name = self.NEW_REPO

        description = u'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                _authentication_token=self.authentication_token()))

        ## run the check page that triggers the flash message

        response = self.app.get(url('repo_check_home', repo_name=repo_name))

        self.assertEqual(response.json, {u'result': True})

        self.checkSessionFlash(response,

                               'Created repository <a href="/%s">%s</a>'

                               % (repo_name, repo_name))

        # test if the repo was created in the database

        new_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name).one()

        self.assertEqual(new_repo.repo_name, repo_name)

        self.assertEqual(new_repo.description, description)

        # test if the repository is visible in the list ?

        response = self.app.get(url('summary_home', repo_name=repo_name))

        response.mustcontain(repo_name)

        response.mustcontain(self.REPO_TYPE)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(safe_str(os.path.join(TESTS_TMP_PATH, repo_name)))

        except vcs.exceptions.VCSError:

        RepoModel().delete(repo_name)

        Session().commit()

    def test_create_in_group(self):

        self.log_user()

        ## create GROUP

        group_name = u'sometest_%s' % self.REPO_TYPE

        gr = RepoGroupModel().create(group_name=group_name,

                                     group_description=u'test',

                                     owner=TEST_USER_ADMIN_LOGIN)

        Session().commit()

        repo_name = u'ingroup'

        repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])

        description = u'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                repo_group=gr.group_id,

                                                _authentication_token=self.authentication_token()))

        ## run the check page that triggers the flash message

        response = self.app.get(url('repo_check_home', repo_name=repo_name_full))

        self.assertEqual(response.json, {u'result': True})

        self.checkSessionFlash(response,

                               'Created repository <a href="/%s">%s</a>'

                               % (repo_name_full, repo_name_full))

        # test if the repo was created in the database

        new_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name_full).one()

        new_repo_id = new_repo.repo_id

        self.assertEqual(new_repo.repo_name, repo_name_full)

        self.assertEqual(new_repo.description, description)

        # test if the repository is visible in the list ?

        response = self.app.get(url('summary_home', repo_name=repo_name_full))

        response.mustcontain(repo_name_full)

        response.mustcontain(self.REPO_TYPE)

        inherited_perms = UserRepoToPerm.query() \

            .filter(UserRepoToPerm.repository_id == new_repo_id).all()

        self.assertEqual(len(inherited_perms), 1)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(safe_str(os.path.join(TESTS_TMP_PATH, repo_name_full)))

        except vcs.exceptions.VCSError:

            RepoGroupModel().delete(group_name)

            Session().commit()

        RepoModel().delete(repo_name_full)

        RepoGroupModel().delete(group_name)

        Session().commit()

    def test_create_in_group_without_needed_permissions(self):

        usr = self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)

        # avoid spurious RepoGroup DetachedInstanceError ...

        authentication_token = self.authentication_token()

        # revoke

        user_model = UserModel()

        # disable fork and create on default user

        user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')

        user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')

        user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')

        user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')

        # disable on regular user

        user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')

        user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')

        user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')

        user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')

        Session().commit()

        ## create GROUP

        group_name = u'reg_sometest_%s' % self.REPO_TYPE

        gr = RepoGroupModel().create(group_name=group_name,

                                     group_description=u'test',

                                     owner=TEST_USER_ADMIN_LOGIN)

        Session().commit()

        group_name_allowed = u'reg_sometest_allowed_%s' % self.REPO_TYPE

        gr_allowed = RepoGroupModel().create(group_name=group_name_allowed,

                                     group_description=u'test',

                                     owner=TEST_USER_REGULAR_LOGIN)

        Session().commit()

        repo_name = u'ingroup'

        repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])

        description = u'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                repo_group=gr.group_id,

                                                _authentication_token=authentication_token))

        response.mustcontain('Invalid value')

        # user is allowed to create in this group

        repo_name = u'ingroup'

        repo_name_full = RepoGroup.url_sep().join([group_name_allowed, repo_name])

        description = u'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                repo_group=gr_allowed.group_id,

                                                _authentication_token=authentication_token))

        ## run the check page that triggers the flash message

        response = self.app.get(url('repo_check_home', repo_name=repo_name_full))

        self.assertEqual(response.json, {u'result': True})

        self.checkSessionFlash(response,

                               'Created repository <a href="/%s">%s</a>'

                               % (repo_name_full, repo_name_full))

        # test if the repo was created in the database

        new_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name_full).one()

        new_repo_id = new_repo.repo_id

        self.assertEqual(new_repo.repo_name, repo_name_full)

        self.assertEqual(new_repo.description, description)

        # test if the repository is visible in the list ?

        response = self.app.get(url('summary_home', repo_name=repo_name_full))

        response.mustcontain(repo_name_full)

        response.mustcontain(self.REPO_TYPE)

        inherited_perms = UserRepoToPerm.query() \

            .filter(UserRepoToPerm.repository_id == new_repo_id).all()

        self.assertEqual(len(inherited_perms), 1)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(safe_str(os.path.join(TESTS_TMP_PATH, repo_name_full)))

        except vcs.exceptions.VCSError:

            RepoGroupModel().delete(group_name)

            Session().commit()

        RepoModel().delete(repo_name_full)

        RepoGroupModel().delete(group_name)

        RepoGroupModel().delete(group_name_allowed)

        Session().commit()

    def test_create_in_group_inherit_permissions(self):

        self.log_user()

        ## create GROUP

        group_name = u'sometest_%s' % self.REPO_TYPE

        gr = RepoGroupModel().create(group_name=group_name,

                                     group_description=u'test',

                                     owner=TEST_USER_ADMIN_LOGIN)

        perm = Permission.get_by_key('repository.write')

        RepoGroupModel().grant_user_permission(gr, TEST_USER_REGULAR_LOGIN, perm)

        ## add repo permissions

        Session().commit()

        repo_name = u'ingroup_inherited_%s' % self.REPO_TYPE

        repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])

        description = u'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                repo_group=gr.group_id,

                                                repo_copy_permissions=True,

                                                _authentication_token=self.authentication_token()))

        ## run the check page that triggers the flash message

        response = self.app.get(url('repo_check_home', repo_name=repo_name_full))

        self.checkSessionFlash(response,

                               'Created repository <a href="/%s">%s</a>'

                               % (repo_name_full, repo_name_full))

        # test if the repo was created in the database

        new_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name_full).one()

        new_repo_id = new_repo.repo_id

        self.assertEqual(new_repo.repo_name, repo_name_full)

        self.assertEqual(new_repo.description, description)

        # test if the repository is visible in the list ?

        response = self.app.get(url('summary_home', repo_name=repo_name_full))

        response.mustcontain(repo_name_full)

        response.mustcontain(self.REPO_TYPE)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(safe_str(os.path.join(TESTS_TMP_PATH, repo_name_full)))

        except vcs.exceptions.VCSError:

            RepoGroupModel().delete(group_name)

            Session().commit()

        #check if inherited permissiona are applied

        inherited_perms = UserRepoToPerm.query() \

            .filter(UserRepoToPerm.repository_id == new_repo_id).all()

        self.assertEqual(len(inherited_perms), 2)

        self.assertTrue(TEST_USER_REGULAR_LOGIN in [x.user.username

                                                    for x in inherited_perms])

        self.assertTrue('repository.write' in [x.permission.permission_name

                                               for x in inherited_perms])

        RepoModel().delete(repo_name_full)

        RepoGroupModel().delete(group_name)

        Session().commit()

    def test_create_remote_repo_wrong_clone_uri(self):

        self.log_user()

        repo_name = self.NEW_REPO

        description = u'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                clone_uri='http://127.0.0.1/repo',

                                                _authentication_token=self.authentication_token()))

        response.mustcontain('Invalid repository URL')

    def test_create_remote_repo_wrong_clone_uri_hg_svn(self):

        self.log_user()

        repo_name = self.NEW_REPO

        description = u'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                clone_uri='svn+http://127.0.0.1/repo',

                                                _authentication_token=self.authentication_token()))

        response.mustcontain('Invalid repository URL')

    def test_delete(self):

        self.log_user()

        repo_name = u'vcs_test_new_to_delete_%s' % self.REPO_TYPE

        description = u'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_type=self.REPO_TYPE,

                                                repo_name=repo_name,

                                                repo_description=description,

                                                _authentication_token=self.authentication_token()))

        ## run the check page that triggers the flash message

        response = self.app.get(url('repo_check_home', repo_name=repo_name))

        self.checkSessionFlash(response,

                               'Created repository <a href="/%s">%s</a>'

                               % (repo_name, repo_name))

        # test if the repo was created in the database

        new_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name).one()

        self.assertEqual(new_repo.repo_name, repo_name)

        self.assertEqual(new_repo.description, description)

        # test if the repository is visible in the list ?

        response = self.app.get(url('summary_home', repo_name=repo_name))

        response.mustcontain(repo_name)

        response.mustcontain(self.REPO_TYPE)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(safe_str(os.path.join(TESTS_TMP_PATH, repo_name)))

        except vcs.exceptions.VCSError:

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

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

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

        response.follow()

        #check if repo was deleted from db

        deleted_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name).scalar()

        self.assertEqual(deleted_repo, None)

        self.assertEqual(os.path.isdir(os.path.join(TESTS_TMP_PATH, repo_name)),

                                  False)

    def test_delete_non_ascii(self):

        self.log_user()

        non_ascii = "ąęł"

        repo_name = "%s%s" % (safe_str(self.NEW_REPO), non_ascii)

        repo_name_unicode = safe_unicode(repo_name)

        description = 'description for newly created repo' + non_ascii

        description_unicode = safe_unicode(description)

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                _authentication_token=self.authentication_token()))

        ## run the check page that triggers the flash message

        response = self.app.get(url('repo_check_home', repo_name=repo_name))

        self.assertEqual(response.json, {u'result': True})

        self.checkSessionFlash(response,

                               u'Created repository <a href="/%s">%s</a>'

                               % (urllib.quote(repo_name), repo_name_unicode))

        # test if the repo was created in the database

        new_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name_unicode).one()

        self.assertEqual(new_repo.repo_name, repo_name_unicode)

        self.assertEqual(new_repo.description, description_unicode)

        # test if the repository is visible in the list ?

        response = self.app.get(url('summary_home', repo_name=repo_name))

        response.mustcontain(repo_name)

        response.mustcontain(self.REPO_TYPE)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(safe_str(os.path.join(TESTS_TMP_PATH, repo_name)))

        except vcs.exceptions.VCSError:

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

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

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

        response.follow()

        #check if repo was deleted from db

        deleted_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name_unicode).scalar()

        self.assertEqual(deleted_repo, None)

        self.assertEqual(os.path.isdir(os.path.join(TESTS_TMP_PATH, repo_name)),

                                  False)

    def test_delete_repo_with_group(self):

        #TODO:

        pass

    def test_delete_browser_fakeout(self):

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

                                 params=dict(_method='delete', _authentication_token=self.authentication_token()))

    def test_show(self):

        self.log_user()

        response = self.app.get(url('summary_home', repo_name=self.REPO))

    def test_edit(self):

        response = self.app.get(url('edit_repo', repo_name=self.REPO))

    def test_set_private_flag_sets_default_to_none(self):

        self.log_user()

        #initially repository perm should be read

        perm = _get_permission_for_user(user='default', repo=self.REPO)

        self.assertTrue(len(perm), 1)

        self.assertEqual(perm[0].permission.permission_name, 'repository.read')

        self.assertEqual(Repository.get_by_repo_name(self.REPO).private, False)

        response = self.app.put(url('put_repo', repo_name=self.REPO),

                        fixture._get_repo_create_params(repo_private=1,

                                                repo_name=self.REPO,

                                                repo_type=self.REPO_TYPE,

                                                user=TEST_USER_ADMIN_LOGIN,

                                                _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               msg='Repository %s updated successfully' % (self.REPO))

        self.assertEqual(Repository.get_by_repo_name(self.REPO).private, True)

        #now the repo default permission should be None

        perm = _get_permission_for_user(user='default', repo=self.REPO)

        self.assertTrue(len(perm), 1)

        self.assertEqual(perm[0].permission.permission_name, 'repository.none')

        response = self.app.put(url('put_repo', repo_name=self.REPO),

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=self.REPO,

                                                repo_type=self.REPO_TYPE,

                                                user=TEST_USER_ADMIN_LOGIN,

                                                _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               msg='Repository %s updated successfully' % (self.REPO))

        self.assertEqual(Repository.get_by_repo_name(self.REPO).private, False)

        #we turn off private now the repo default permission should stay None

        perm = _get_permission_for_user(user='default', repo=self.REPO)

        self.assertTrue(len(perm), 1)

        self.assertEqual(perm[0].permission.permission_name, 'repository.none')

        #update this permission back

        perm[0].permission = Permission.get_by_key('repository.read')

        Session().add(perm[0])

        Session().commit()

    def test_set_repo_fork_has_no_self_id(self):

        self.log_user()

        repo = Repository.get_by_repo_name(self.REPO)

        response = self.app.get(url('edit_repo_advanced', repo_name=self.REPO))

        opt = """<option value="%s">%s</option>""" % (repo.repo_id, self.REPO)

        response.mustcontain(no=[opt])

    def test_set_fork_of_other_repo(self):

        self.log_user()

        other_repo = u'other_%s' % self.REPO_TYPE

        fixture.create_repo(other_repo, repo_type=self.REPO_TYPE)

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(other_repo)

        response = self.app.put(url('edit_repo_advanced_fork', repo_name=self.REPO),

                                params=dict(id_fork_of=repo2.repo_id, _authentication_token=self.authentication_token()))

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(other_repo)

        self.checkSessionFlash(response,

            'Marked repository %s as fork of %s' % (repo.repo_name, repo2.repo_name))

        assert repo.fork == repo2

        response = response.follow()

        # check if given repo is selected

        opt = """<option value="%s" selected="selected">%s</option>""" % (

                    repo2.repo_id, repo2.repo_name)

        response.mustcontain(opt)

        fixture.destroy_repo(other_repo, forks='detach')

    def test_set_fork_of_other_type_repo(self):

        self.log_user()

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(self.OTHER_TYPE_REPO)

        response = self.app.put(url('edit_repo_advanced_fork', repo_name=self.REPO),

                                params=dict(id_fork_of=repo2.repo_id, _authentication_token=self.authentication_token()))

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(self.OTHER_TYPE_REPO)

        self.checkSessionFlash(response,

            'Cannot set repository as fork of repository with other type')

    def test_set_fork_of_none(self):

        self.log_user()

        ## mark it as None

        response = self.app.put(url('edit_repo_advanced_fork', repo_name=self.REPO),

                                params=dict(id_fork_of=None, _authentication_token=self.authentication_token()))

        repo = Repository.get_by_repo_name(self.REPO)

        repo2 = Repository.get_by_repo_name(self.OTHER_TYPE_REPO)

        self.checkSessionFlash(response,

                               'Marked repository %s as fork of %s'

                               % (repo.repo_name, "Nothing"))

        assert repo.fork is None

    def test_set_fork_of_same_repo(self):

        self.log_user()

        repo = Repository.get_by_repo_name(self.REPO)

        response = self.app.put(url('edit_repo_advanced_fork', repo_name=self.REPO),

                                params=dict(id_fork_of=repo.repo_id, _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               'An error occurred during this operation')

    def test_create_on_top_level_without_permissions(self):

        usr = self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)

        # revoke

        user_model = UserModel()

        # disable fork and create on default user

        user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')

        user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')

        user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')

        user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')

        # disable on regular user

        user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')

        user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')

        user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')

        user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')

        Session().commit()

        user = User.get(usr['user_id'])

        repo_name = self.NEW_REPO + u'no_perms'

        description = 'description for newly created repo'

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

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                _authentication_token=self.authentication_token()))

        response.mustcontain('<span class="error-message">Invalid value</span>')

        RepoModel().delete(repo_name)

        Session().commit()

    @mock.patch.object(RepoModel, '_create_filesystem_repo', error_function)

    def test_create_repo_when_filesystem_op_fails(self):