config['pylons.strict_tmpl_context'] = True

    test = os.path.split(config['__file__'])[-1] == 'test.ini'

    if test:

        if test_env is None:

            test_env = not int(os.environ.get('KALLITHEA_NO_TMP_PATH', 0))

        if test_index is None:

            test_index = not int(os.environ.get('KALLITHEA_WHOOSH_TEST_DISABLE', 0))

        if os.environ.get('TEST_DB'):

            # swap config if we pass enviroment variable

            config['sqlalchemy.url'] = os.environ.get('TEST_DB')

        from kallithea.lib.utils import create_test_env, create_test_index

        #set KALLITHEA_NO_TMP_PATH=1 to disable re-creating the database and

        #test repos

        if test_env:

            create_test_env(TESTS_TMP_PATH, config)

        #set KALLITHEA_WHOOSH_TEST_DISABLE=1 to disable whoosh index during tests

        if test_index:

            create_test_index(TESTS_TMP_PATH, config, True)

    # MULTIPLE DB configs

    # Setup the SQLAlchemy database engine

    sa_engine = engine_from_config(config, 'sqlalchemy.')

    init_model(sa_engine)

            if password is None:

                password = get_password()

                if not password:

                    #second try

                    password = get_password()

                    if not password:

                        sys.exit()

            if email is None:

                email = raw_input('Specify admin email:')

            self.create_user(username, password, email, True)

        else:

            log.info('creating admin and regular test users')

            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

            self.create_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS,

                             TEST_USER_ADMIN_EMAIL, True)

            self.create_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,

                             TEST_USER_REGULAR_EMAIL, False)

            self.create_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS,

            .run(full_index=full_index)

        l.release()

    except LockHeld:

        pass

def create_test_env(repos_test_path, config):

    """

    Makes a fresh database and

    install test repository into tmp dir

    """

    from kallithea.lib.db_manage import DbManage

    # PART ONE create db

    dbconf = config['sqlalchemy.url']

    log.debug('making test db %s', dbconf)

    # create test dir if it doesn't exist

    if not os.path.isdir(repos_test_path):

        log.debug('Creating testdir %s', repos_test_path)

        os.makedirs(repos_test_path)

    dbmanage = DbManage(log_sql=True, dbconf=dbconf, root=config['here'],

                        tests=True)

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

"""

Kallithea test package

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

"""

import pytest

#

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

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

"""

Tests for the JSON-RPC web api.

"""

import os

import random

import mock

from kallithea.tests.fixture import Fixture

from kallithea.lib.compat import json

from kallithea.lib.auth import AuthUser

from kallithea.model.user import UserModel

from kallithea.model.user_group import UserGroupModel

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.meta import Session

from kallithea.model.scm import ScmModel

from kallithea.model.gist import GistModel

from kallithea.model.db import Repository, User, Setting, Ui

from kallithea.lib.utils2 import time_to_datetime

# 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 kallithea.tests.api.api_base import _BaseTestApi

class TestGitApi(_BaseTestApi, TestController):

    REPO = GIT_REPO

    REPO_TYPE = 'git'

# 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 kallithea.tests.api.api_base import _BaseTestApi

class TestHgApi(_BaseTestApi, TestController):

    REPO = HG_REPO

    REPO_TYPE = 'hg'

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

import os

import re

import time

import pylons

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

from kallithea import is_windows

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

from kallithea.model.meta import Session

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', 'environ', 'url', 'TestController',

    'ldap_lib_installed', 'pam_lib_installed', 'invalidate_all_caches',

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

]

# Invoke websetup with the current config file

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

environ = {}

#SOME GLOBALS FOR TESTS

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'

        try:

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

            if _matcher(msg, m):

                return

        except IndexError:

            pass

        pytest.fail(safe_str(u'msg `%s` not found in session flash (skipping %s): %s' %

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

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

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)

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

"""

Helpers for fixture generation

"""

import os

import time

from kallithea.model.db import Repository, User, RepoGroup, UserGroup, Gist

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

from kallithea.model.user import UserModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.user_group import UserGroupModel

from kallithea.model.gist import GistModel

from kallithea.model.scm import ScmModel

from kallithea.lib.vcs.backends.base import EmptyChangeset

from os.path import dirname

FIXTURES = os.path.join(dirname(dirname(os.path.abspath(__file__))), 'tests', 'fixtures')

import os

import csv

import datetime

from kallithea.model.db import UserLog

from kallithea.model.meta import Session

from kallithea.lib.utils2 import safe_unicode

from os.path import dirname

FIXTURES = os.path.join(dirname(dirname(os.path.abspath(__file__))), 'fixtures')

class TestAdminController(TestController):

    @classmethod

    def setup_class(cls):

from kallithea.model.db import Setting

class TestAuthSettingsController(TestController):

    def _enable_plugins(self, plugins_list):

        test_url = url(controller='admin/auth_settings',

                       action='auth_settings')

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

        for plugin in plugins_list.split(','):

            enable = plugin.partition('kallithea.lib.auth_modules.')[-1]

            params.update({'%s_enabled' % enable: True})

from kallithea.model.db import Setting

class TestDefaultsController(TestController):

    def test_index(self):

        self.log_user()

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

        response.mustcontain('default_repo_private')

        response.mustcontain('default_repo_enable_statistics')

        response.mustcontain('default_repo_enable_downloads')

        response.mustcontain('default_repo_enable_locking')

from kallithea.model.gist import GistModel

from kallithea.model.meta import Session

from kallithea.model.db import User, Gist

def _create_gist(f_name, content='some gist', lifetime=-1,

                 description=u'gist-desc', gist_type='public',

                 owner=TEST_USER_ADMIN_LOGIN):

    gist_mapping = {

        f_name: {'content': content}

    }

    user = User.get_by_username(owner)

from kallithea.model.db import User

from kallithea.model.user import UserModel

from kallithea.model.notification import NotificationModel

from kallithea.model.meta import Session

from kallithea.lib import helpers as h

class TestNotificationsController(TestController):

    def setup_method(self, method):

        self.remove_all_notifications()

import time

from kallithea.model.db import User, UserIpMap

from kallithea.model.user import UserModel

from kallithea.model.meta import Session

class TestAdminPermissionsController(TestController):

    def test_index(self):

        self.log_user()

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

        # Test response...

    def test_index_ips(self):

        self.log_user()

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

        # Test response...

class TestRepoGroupsController(TestController):

    pass

import os

import mock

import urllib

import pytest

from kallithea.lib import vcs

from kallithea.lib.utils2 import safe_str, safe_unicode

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

    Permission, Ui

from kallithea.model.user import UserModel

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

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

import tempfile

from kallithea.model.db import Setting, Ui

from kallithea.tests.fixture import Fixture

fixture = Fixture()

class TestAdminSettingsController(TestController):

    def test_index_main(self):

        self.log_user()

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

    def test_index_mapping(self):

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

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

from kallithea.model.meta import Session

TEST_USER_GROUP = u'admins_test'

class TestAdminUsersGroupsController(TestController):

    def test_index(self):

        self.log_user()

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

        # Test response...

#

# 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.fixture import Fixture

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

class TestChangelogController(TestController):

    def test_index_hg(self):

        self.log_user()

        response = self.app.get(url(controller='changelog', action='index',

                                    repo_name=HG_REPO))

        response.mustcontain('''id="chg_20" class="container mergerow"''')

        response.mustcontain(

            """<input class="changeset_range" """

class TestChangesetController(TestController):

    def test_index(self):

        response = self.app.get(url(controller='changeset', action='index',

                                    repo_name=HG_REPO, revision='tip'))

        # Test response...

    def test_changeset_range(self):

        #print self.app.get(url(controller='changelog', action='index', repo_name=HG_REPO))

        response = self.app.get(url(controller='changeset', action='index',

from kallithea.model.db import ChangesetComment, Notification, \

    UserNotification

from kallithea.model.meta import Session

class TestChangeSetCommentsController(TestController):

    def setup_method(self, method):

        for x in ChangesetComment.query().all():

            Session().delete(x)

        Session().commit()