syntax: glob

*.pyc

*.swp

*.sqlite

*.tox

*.egg-info

*.egg

*.mo

.eggs/

tarballcache/

syntax: regexp

^rcextensions

^build

^dist/

^docs/build/

^docs/_build/

^data$

^sql_dumps/

^\.settings$

^\.project$

^\.pydevproject$

^\.coverage$

^kallithea\.db$

^test\.db$

^Kallithea\.egg-info$

^my\.ini$

^fabfile.py

^\.idea$

include           Apache-License-2.0.txt

include           CONTRIBUTORS

include           COPYING

include           LICENSE-MERGELY.html

include           LICENSE.md

include           MIT-Permissive-License.txt

include           README.rst

include           development.ini

recursive-include docs *

recursive-include init.d *

include           kallithea/bin/ldap_sync.conf

include           kallithea/bin/template.ini.mako

include           kallithea/config/deployment.ini_tmpl

recursive-include kallithea/i18n *

recursive-include kallithea/lib/dbmigrate *.py_tmpl README migrate.cfg

recursive-include kallithea/public *

recursive-include kallithea/templates *

recursive-include kallithea/tests/fixtures *

recursive-include kallithea/tests/scripts *

include           kallithea/tests/vcs/aconfig

.. _contributing:

=========================

Contributing to Kallithea

=========================

Kallithea is developed and maintained by its users. Please join us and scratch

your own itch.

Infrastructure

--------------

The main repository is hosted at Our Own Kallithea (aka OOK) on

https://kallithea-scm.org/repos/kallithea/ (which is our self-hosted instance

of Kallithea).

For now, we use Bitbucket_ for `Pull Requests`_ and `Issue Tracker`_ services. The

issue tracker is for tracking bugs, not for support, discussion, or ideas -

please use the `mailing list`_ to reach the community.

We use Weblate_ to translate the user interface messages into languages other

than English. Join our project on `Hosted Weblate`_ to help us.

To register, you can use your Bitbucket or GitHub account. See :ref:`translations`

for more details.

Getting started

---------------

To get started with development::

        hg clone https://kallithea-scm.org/repos/kallithea

        cd kallithea

        virtualenv ../kallithea-venv

        source ../kallithea-venv/bin/activate

        python setup.py develop

        paster make-config Kallithea my.ini

        paster setup-db my.ini --user=user --email=user@example.com --password=password --repos=/tmp

        paster serve my.ini --reload &

        firefox http://127.0.0.1:5000/

You can also start out by forking https://bitbucket.org/conservancy/kallithea

on Bitbucket_ and create a local clone of your own fork.

Running tests

-------------

After finishing your changes make sure all tests pass cleanly. You can run

the testsuite running ``nosetests`` from the project root, or if you use tox

run ``tox`` for python2.6-2.7 with multiple database test.

It is possible to avoid recreating the full test database on each invocation of

the tests, thus eliminating the initial delay. To achieve this, run the tests as::

    KALLITHEA_WHOOSH_TEST_DISABLE=1 KALLITHEA_NO_TMP_PATH=1 nosetests

    kill -9 $(cat test.pid)

You can run individual tests by specifying their path as argument to nosetests.

nosetests also has many more options, see `nosetests -h`. Some useful options

are::

    -x, --stop            Stop running tests after the first error or failure

    -s, --nocapture       Don't capture stdout (any stdout output will be

                          printed immediately) [NOSE_NOCAPTURE]

    --failed              Run the tests that failed in the last test run.

Coding/contribution guidelines

------------------------------

Kallithea is GPLv3 and we assume all contributions are made by the

committer/contributor and under GPLv3 unless explicitly stated. We do care a

lot about preservation of copyright and license information for existing code

that is brought into the project.

We don't have a formal coding/formatting standard. We are currently using a mix

of Mercurial (http://mercurial.selenic.com/wiki/CodingStyle), pep8, and

consistency with existing code. Run whitespacecleanup.sh to avoid stupid

whitespace noise in your patches.

We support both Python 2.6.x and 2.7.x and nothing else. For now we don't care

about Python 3 compatibility.

We try to support the most common modern web browsers. IE9 is still supported

to the extent it is feasible, IE8 is not.

We primarily support Linux and OS X on the server side but Windows should also work.

Html templates should use 2 spaces for indentation ... but be pragmatic. We

should use templates cleverly and avoid duplication. We should use reasonable

semantic markup with classes and ids that can be used for styling and testing.

We should only use inline styles in places where it really is semantic (such as

display:none).

JavaScript must use ';' between/after statements. Indentation 4 spaces. Inline

multiline functions should be indented two levels - one for the () and one for

{}. jQuery value arrays should have a leading $.

Commit messages should have a leading short line summarizing the changes. For

bug fixes, put "(Issue #123)" at the end of this line.

Contributions will be accepted in most formats - such as pull requests on

bitbucket, something hosted on your own Kallithea instance, or patches sent by

email to the kallithea-general mailing list.

Make sure to test your changes both manually and with the automatic tests

before posting.

We care about quality and review and keeping a clean repository history. We

might give feedback that requests polishing contributions until they are

"perfect". We might also rebase and collapse and make minor adjustments to your

changes when we apply them.

We try to make sure we have consensus on the direction the project is taking.

Everything non-sensitive should be discussed in public - preferably on the

mailing list.  We aim at having all non-trivial changes reviewed by at least

one other core developer before pushing. Obvious non-controversial changes will

be handled more casually.

For now we just have one official branch ("default") and will keep it so stable

that it can be (and is) used in production. Experimental changes should live

elsewhere (for example in a pull request) until they are ready.

.. _translations:

.. include:: ./../kallithea/i18n/how_to

"Roadmap"

---------

We do not have a road map but are waiting for your contributions. Refer to the

wiki_ for some ideas of places we might want to go - contributions in these

areas are very welcome.

Thank you for your contribution!

--------------------------------

.. _Weblate: http://weblate.org/

.. _Issue Tracker: https://bitbucket.org/conservancy/kallithea/issues?status=new&status=open

.. _Pull Requests: https://bitbucket.org/conservancy/kallithea/pull-requests

.. _bitbucket: http://bitbucket.org/

.. _mailing list: http://lists.sfconservancy.org/mailman/listinfo/kallithea-general

.. _Hosted Weblate: https://hosted.weblate.org/projects/kallithea/kallithea/

.. _wiki: https://bitbucket.org/conservancy/kallithea/wiki/Home

============

Translations

============

Translations are available on Hosted Weblate at the following URL:

    https://hosted.weblate.org/projects/kallithea/kallithea/

Registered users may contribute to the existing languages, or request a new

language translations.

Translating using Weblate

-------------------------

Weblate_ offers a simple and easy to use interface featuring glossary, machine

translation, suggestions based on similar translations in other projects,

automatic checks etc. Weblate imports the source code tree directly from

the version control system, and commits edits back from time to time.

When registering at Weblate, make sure you name and email address you prefer to

be used when your changes are committed. We can and probably will amend changesets

coming from Weblate, but having things right from the beginning makes things easier.

Weblate performs sanity checks all the time and tries to prevent you from ignoring

them. Most common mistakes are inconsistent punctuation, whitespaces, missing or extra

format parameters, untranslated strings copied into the translation. Please perform

necessary corrections when they're needed, or override the false positives.

Merging translations from Weblate

---------------------------------

Weblate rebases its changes every time it pulls from our repository. Pulls are triggered

by a web hook from Our Own Kallithea every time it receives new commits. Usually merging

the new translations is a straightforward process consisting of a pull from Weblate-hosted

repository which is available under Data Exports tab in Weblate interface.

Weblate tries to minimise the number of commits, but that's not always work, especially

when two translators work with different languages at more or less the same time.

It makes sense sometimes to re-order or fold commits by the same author when they touch

just the same language translation. That, however, may confuse Weblate sometimes, in

which case it should be manually convinced it has to discard the commits it created by

using its administrative interface.

Manual creation of a new language translation

---------------------------------------------

In the prepared development environment, run the following to ensure

all translation strings are extracted and up-to-date::

    python setup.py extract_messages

Create new language by executing following command::

    python setup.py init_catalog -l <new_language_code>

This creates a new translation under directory `kallithea/i18n/<new_language_code>`

based on the translation template file, `kallithea/i18n/kallithea.pot`.

Edit the new PO file located in `LC_MESSAGES` directory with poedit or your

favorite PO files editor. After you finished with the translations, check the

translation file for errors by executing::

    msgfmt -f -c kallithea/i18n/<new_language_code>/LC_MESSAGES/<updated_file.po>

Finally, compile the translations::

    python setup.py compile_catalog -l <new_language_code>

Updating translations

---------------------

Extract the latest versions of strings for translation by running::

    python setup.py extract_messages

Update the PO file by doing::

    python setup.py update_catalog -l <new_language_code>

Edit the new updated translation file. Repeat all steps after `init_catalog` step from

new translation instructions

Testing translations

--------------------

    lang=<new_language_code>

Run Kallithea tests by executing::

    nosetests

import os

import sys

import logging

import pkg_resources

from paste.deploy import loadapp

import pylons.test

from pylons.i18n.translation import _get_translator

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)

    logging.disable(logging.NOTSET)

    # Setup the config and app_globals, only works if we can get

    # to the config object

    conf = getattr(pylons.test.pylonsapp, 'config')

    if conf:

        pylons.config._push_object(conf)

        if 'pylons.app_globals' in conf:

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

    # Initialize a translator for tests that utilize i18n

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

    pylons.translator._push_object(translator)

    return pylons.test.pylonsapp

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

"""

kallithea.tests.other.manual_test_vcs_operations

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Test suite for making push/pull operations.

Run it in two terminals::

 KALLITHEA_WHOOSH_TEST_DISABLE=1 KALLITHEA_NO_TMP_PATH=1 nosetests kallithea/tests/other/manual_test_vcs_operations.py

You must have git > 1.8.1 for tests to work fine

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Dec 30, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import re

import tempfile

import time

from os.path import join as jn

from tempfile import _RandomNameSequence

from subprocess import Popen, PIPE

from kallithea.tests import *

from kallithea.model.db import User, Repository, UserIpMap, CacheInvalidation

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

from kallithea.model.user import UserModel

DEBUG = True

HOST = '127.0.0.1:4999'  # test host

class Command(object):

    def __init__(self, cwd):

        self.cwd = cwd

    def execute(self, cmd, *args):

        """

        Runs command on the system with given ``args``.

        """

        command = cmd + ' ' + ' '.join(args)

        if DEBUG:

            print '*** CMD %s ***' % command

        p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, cwd=self.cwd)

        stdout, stderr = p.communicate()

        if DEBUG:

            print 'stdout:', repr(stdout)

            print 'stderr:', repr(stderr)

        return stdout, stderr

def _get_tmp_dir():

    return tempfile.mkdtemp(prefix='rc_integration_test')

def _construct_url(repo, dest=None, **kwargs):

    if dest is None:

        #make temp clone

        dest = _get_tmp_dir()

    params = {

        'user': TEST_USER_ADMIN_LOGIN,

        'passwd': TEST_USER_ADMIN_PASS,

        'host': HOST,

        'cloned_repo': repo,

        'dest': dest

    }

    params.update(**kwargs)

    if params['user'] and params['passwd']:

        _url = 'http://%(user)s:%(passwd)s@%(host)s/%(cloned_repo)s %(dest)s' % params

    else:

        _url = 'http://(host)s/%(cloned_repo)s %(dest)s' % params

    return _url

def _add_files_and_push(vcs, DEST, **kwargs):

    """

    Generate some files, add it to DEST repo and push back

    vcs is git or hg and defines what VCS we want to make those files for

    :param vcs:

    :param DEST:

    """

    # commit some stuff into this repo

    cwd = path = jn(DEST)

    #added_file = jn(path, '%ssetupążźć.py' % _RandomNameSequence().next())

    added_file = jn(path, '%ssetup.py' % _RandomNameSequence().next())

    Command(cwd).execute('touch %s' % added_file)

    Command(cwd).execute('%s add %s' % (vcs, added_file))

    for i in xrange(kwargs.get('files_no', 3)):

        cmd = """echo 'added_line%s' >> %s""" % (i, added_file)

        Command(cwd).execute(cmd)

        author_str = 'User ǝɯɐᴎ <me@email.com>'

        if vcs == 'hg':

            cmd = """hg commit -m 'commited new %s' -u '%s' %s """ % (

                i, author_str, added_file

            )

        elif vcs == 'git':

            cmd = """EMAIL="me@email.com" git commit -m 'commited new %s' --author '%s' %s """ % (

                i, author_str, added_file

            )

        Command(cwd).execute(cmd)

    # PUSH it back

    _REPO = None

    if vcs == 'hg':

        _REPO = HG_REPO

    elif vcs == 'git':

        _REPO = GIT_REPO

    kwargs['dest'] = ''

    clone_url = _construct_url(_REPO, **kwargs)

    if 'clone_url' in kwargs:

        clone_url = kwargs['clone_url']

    stdout = stderr = None

    if vcs == 'hg':

        stdout, stderr = Command(cwd).execute('hg push --verbose', clone_url)

    elif vcs == 'git':

        stdout, stderr = Command(cwd).execute('git push --verbose', clone_url + " master")

    return stdout, stderr

def set_anonymous_access(enable=True):

    user = User.get_by_username(User.DEFAULT_USER)

    user.active = enable

    Session().add(user)

    Session().commit()

    print '\tanonymous access is now:', enable

    if enable != User.get_by_username(User.DEFAULT_USER).active:

        raise Exception('Cannot set anonymous access')

#==============================================================================

# TESTS

#==============================================================================

def _check_proper_git_push(stdout, stderr):

    #WTF Git stderr is output ?!

    assert 'fatal' not in stderr

    assert 'rejected' not in stderr

    assert 'Pushing to' in stderr

    assert 'master -> master' in stderr

class TestVCSOperations(BaseTestCase):

    @classmethod

    def setup_class(cls):

        #DISABLE ANONYMOUS ACCESS

        set_anonymous_access(False)

    def setUp(self):

        r = Repository.get_by_repo_name(GIT_REPO)

        Repository.unlock(r)

        r.enable_locking = False

        Session().add(r)

        Session().commit()

        r = Repository.get_by_repo_name(HG_REPO)

        Repository.unlock(r)

        r.enable_locking = False

        Session().add(r)

        Session().commit()

    def test_clone_hg_repo_by_admin(self):

        clone_url = _construct_url(HG_REPO)

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        assert 'requesting all changes' in stdout

        assert 'adding changesets' in stdout

        assert 'adding manifests' in stdout

        assert 'adding file changes' in stdout

        assert stderr == ''

    def test_clone_git_repo_by_admin(self):

        clone_url = _construct_url(GIT_REPO)

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        assert 'Cloning into' in stdout + stderr

        assert stderr == '' or stdout == ''

    def test_clone_wrong_credentials_hg(self):

        clone_url = _construct_url(HG_REPO, passwd='bad!')

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        assert 'abort: authorization failed' in stderr

    def test_clone_wrong_credentials_git(self):

        clone_url = _construct_url(GIT_REPO, passwd='bad!')

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        assert 'fatal: Authentication failed' in stderr

    def test_clone_git_dir_as_hg(self):

        clone_url = _construct_url(GIT_REPO)

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        assert 'HTTP Error 404: Not Found' in stderr

    def test_clone_hg_repo_as_git(self):

        clone_url = _construct_url(HG_REPO)

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        assert 'not found' in stderr

    def test_clone_non_existing_path_hg(self):

        clone_url = _construct_url('trololo')

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        assert 'HTTP Error 404: Not Found' in stderr

    def test_clone_non_existing_path_git(self):

        clone_url = _construct_url('trololo')

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        assert 'not found' in stderr

    def test_push_new_file_hg(self):

        DEST = _get_tmp_dir()

        clone_url = _construct_url(HG_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        stdout, stderr = _add_files_and_push('hg', DEST)

        assert 'pushing to' in stdout

        assert 'Repository size' in stdout

        assert 'Last revision is now' in stdout

    def test_push_new_file_git(self):

        DEST = _get_tmp_dir()

        clone_url = _construct_url(GIT_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        # commit some stuff into this repo

        stdout, stderr = _add_files_and_push('git', DEST)

        print [(x.repo_full_path,x.repo_path) for x in Repository.get_all()]

        _check_proper_git_push(stdout, stderr)

    def test_push_invalidates_cache_hg(self):

        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

                                               ==HG_REPO).scalar()

        if not key:

            key = CacheInvalidation(HG_REPO, HG_REPO)

        key.cache_active = True

        Session().add(key)

        Session().commit()

        DEST = _get_tmp_dir()

        clone_url = _construct_url(HG_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        stdout, stderr = _add_files_and_push('hg', DEST, files_no=1)

        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

                                               ==HG_REPO).one()

        self.assertEqual(key.cache_active, False)

    def test_push_invalidates_cache_git(self):

        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

                                               ==GIT_REPO).scalar()

        if not key:

            key = CacheInvalidation(GIT_REPO, GIT_REPO)

        key.cache_active = True

        Session().add(key)

        Session().commit()

        DEST = _get_tmp_dir()

        clone_url = _construct_url(GIT_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        # commit some stuff into this repo

        stdout, stderr = _add_files_and_push('git', DEST, files_no=1)

        _check_proper_git_push(stdout, stderr)

        key = CacheInvalidation.query().filter(CacheInvalidation.cache_key

                                               ==GIT_REPO).one()

        print CacheInvalidation.get_all()

        self.assertEqual(key.cache_active, False)

    def test_push_wrong_credentials_hg(self):

        DEST = _get_tmp_dir()

        clone_url = _construct_url(HG_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        stdout, stderr = _add_files_and_push('hg', DEST, user='bad',

                                             passwd='name')

        assert 'abort: authorization failed' in stderr

    def test_push_wrong_credentials_git(self):

        DEST = _get_tmp_dir()

        clone_url = _construct_url(GIT_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        stdout, stderr = _add_files_and_push('git', DEST, user='bad',

                                             passwd='name')

        assert 'fatal: Authentication failed' in stderr

    def test_push_back_to_wrong_url_hg(self):

        DEST = _get_tmp_dir()

        clone_url = _construct_url(HG_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        stdout, stderr = _add_files_and_push('hg', DEST,

                                    clone_url='http://%s/tmp' % HOST)

        assert 'HTTP Error 404: Not Found' in stderr

    def test_push_back_to_wrong_url_git(self):

        DEST = _get_tmp_dir()

        clone_url = _construct_url(GIT_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        stdout, stderr = _add_files_and_push('git', DEST,

                                    clone_url='http://%s/tmp' % HOST)

        assert 'not found' in stderr

    def test_clone_and_create_lock_hg(self):

        # enable locking

        r = Repository.get_by_repo_name(HG_REPO)

        r.enable_locking = True

        Session().add(r)

        Session().commit()

        # clone

        clone_url = _construct_url(HG_REPO)

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        #check if lock was made

        r = Repository.get_by_repo_name(HG_REPO)

        assert r.locked[0] == User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id

    def test_clone_and_create_lock_git(self):

        # enable locking

        r = Repository.get_by_repo_name(GIT_REPO)

        r.enable_locking = True

        Session().add(r)

        Session().commit()

        # clone

        clone_url = _construct_url(GIT_REPO)

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        #check if lock was made

        r = Repository.get_by_repo_name(GIT_REPO)

        assert r.locked[0] == User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id

    def test_clone_after_repo_was_locked_hg(self):

        #lock repo

        r = Repository.get_by_repo_name(HG_REPO)

        Repository.lock(r, User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id)

        #pull fails since repo is locked

        clone_url = _construct_url(HG_REPO)

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        msg = ("""abort: HTTP Error 423: Repository `%s` locked by user `%s`"""

                % (HG_REPO, TEST_USER_ADMIN_LOGIN))

        assert msg in stderr

    def test_clone_after_repo_was_locked_git(self):

        #lock repo

        r = Repository.get_by_repo_name(GIT_REPO)

        Repository.lock(r, User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id)

        #pull fails since repo is locked

        clone_url = _construct_url(GIT_REPO)

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        msg = ("""The requested URL returned error: 423""")

        assert msg in stderr

    def test_push_on_locked_repo_by_other_user_hg(self):

        #clone some temp

        DEST = _get_tmp_dir()

        clone_url = _construct_url(HG_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        #lock repo

        r = Repository.get_by_repo_name(HG_REPO)

        # let this user actually push !

        RepoModel().grant_user_permission(repo=r, user=TEST_USER_REGULAR_LOGIN,

                                          perm='repository.write')

        Session().commit()

        Repository.lock(r, User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id)

        #push fails repo is locked by other user !

        stdout, stderr = _add_files_and_push('hg', DEST,

                                             user=TEST_USER_REGULAR_LOGIN,

                                             passwd=TEST_USER_REGULAR_PASS)

        msg = ("""abort: HTTP Error 423: Repository `%s` locked by user `%s`"""

                % (HG_REPO, TEST_USER_ADMIN_LOGIN))

        assert msg in stderr

    def test_push_on_locked_repo_by_other_user_git(self):

        #clone some temp

        DEST = _get_tmp_dir()

        clone_url = _construct_url(GIT_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        #lock repo

        r = Repository.get_by_repo_name(GIT_REPO)

        # let this user actually push !

        RepoModel().grant_user_permission(repo=r, user=TEST_USER_REGULAR_LOGIN,

                                          perm='repository.write')

        Session().commit()

        Repository.lock(r, User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id)

        #push fails repo is locked by other user !

        stdout, stderr = _add_files_and_push('git', DEST,

                                             user=TEST_USER_REGULAR_LOGIN,

                                             passwd=TEST_USER_REGULAR_PASS)

        err = 'Repository `%s` locked by user `%s`' % (GIT_REPO, TEST_USER_ADMIN_LOGIN)

        assert err in stderr

        #TODO: fix this somehow later on Git, Git is stupid and even if we throw

        #back 423 to it, it makes ANOTHER request and we fail there with 405 :/

        msg = ("""abort: HTTP Error 423: Repository `%s` locked by user `%s`"""

                % (GIT_REPO, TEST_USER_ADMIN_LOGIN))

        #msg = "405 Method Not Allowed"

        #assert msg in stderr

    def test_push_unlocks_repository_hg(self):

        # enable locking

        r = Repository.get_by_repo_name(HG_REPO)

        r.enable_locking = True

        Session().add(r)

        Session().commit()

        #clone some temp

        DEST = _get_tmp_dir()

        clone_url = _construct_url(HG_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        #check for lock repo after clone

        r = Repository.get_by_repo_name(HG_REPO)

        uid = User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id

        assert r.locked[0] == uid

        #push is ok and repo is now unlocked

        stdout, stderr = _add_files_and_push('hg', DEST)

        assert ('remote: Released lock on repo `%s`' % HG_REPO) in stdout

        #we need to cleanup the Session Here !

        Session.remove()

        r = Repository.get_by_repo_name(HG_REPO)

        assert r.locked == [None, None]

    #TODO: fix me ! somehow during tests hooks don't get called on Git

    def test_push_unlocks_repository_git(self):

        # enable locking

        r = Repository.get_by_repo_name(GIT_REPO)

        r.enable_locking = True

        Session().add(r)

        Session().commit()

        #clone some temp

        DEST = _get_tmp_dir()

        clone_url = _construct_url(GIT_REPO, dest=DEST)

        stdout, stderr = Command('/tmp').execute('git clone', clone_url)

        #check for lock repo after clone

        r = Repository.get_by_repo_name(GIT_REPO)

        assert r.locked[0] == User.get_by_username(TEST_USER_ADMIN_LOGIN).user_id

        #push is ok and repo is now unlocked

        stdout, stderr = _add_files_and_push('git', DEST)

        _check_proper_git_push(stdout, stderr)

        #assert ('remote: Released lock on repo `%s`' % GIT_REPO) in stdout

        #we need to cleanup the Session Here !

        Session.remove()

        r = Repository.get_by_repo_name(GIT_REPO)

        assert r.locked == [None, None]

    def test_ip_restriction_hg(self):

        user_model = UserModel()

        try:

            user_model.add_extra_ip(TEST_USER_ADMIN_LOGIN, '10.10.10.10/32')

            Session().commit()

            clone_url = _construct_url(HG_REPO)

            stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

            assert 'abort: HTTP Error 403: Forbidden' in stderr

        finally:

            #release IP restrictions

            for ip in UserIpMap.getAll():

                UserIpMap.delete(ip.ip_id)

            Session().commit()

        time.sleep(2)

        clone_url = _construct_url(HG_REPO)

        stdout, stderr = Command('/tmp').execute('hg clone', clone_url)

        assert 'requesting all changes' in stdout

        assert 'adding changesets' in stdout

        assert 'adding manifests' in stdout

        assert 'adding file changes' in stdout

        assert stderr == ''

    def test_ip_restriction_git(self):

        user_model = UserModel()

        try:

            user_model.add_extra_ip(TEST_USER_ADMIN_LOGIN, '10.10.10.10/32')

            Session().commit()

            clone_url = _construct_url(GIT_REPO)

            stdout, stderr = Command('/tmp').execute('git clone', clone_url)