tests: move test.ini to kallithea/tests/

.hgignore

@@ -1,29 +1,30 b''
 syntax: glob
 *.pyc
 *.swp
 *.sqlite
 *.tox
 *.egg-info
 *.egg
 *.mo
 .eggs/
 tarballcache/
 
 syntax: regexp
 ^rcextensions
 ^build
 ^dist/
 ^docs/build/
 ^docs/_build/
 ^data$
+^kallithea/tests/data$
 ^sql_dumps/
 ^\.settings$
 ^\.project$
 ^\.pydevproject$
 ^\.coverage$
 ^kallithea\.db$
 ^test\.db$
 ^Kallithea\.egg-info$
 ^my\.ini$
 ^fabfile.py
 ^\.idea$

MANIFEST.in

@@ -1,21 +1,21 b''
 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/test.ini
 include           kallithea/tests/vcs/aconfig
-include           test.ini

docs/contributing.rst

@@ -1,149 +1,149 b''
 .. _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=[e-mail] --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.
 
-When using `nosetests`, the `test.ini` file is used with an SQLite database. Edit
-this file to change your testing enviroment.
+When running tests, Kallithea uses `kallithea/tests/test.ini` and populates the
+SQLite database specified there.
 
 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::
 
-    paster serve test.ini --pid-file=test.pid --daemon
+    paster serve kallithea/tests/test.ini --pid-file=test.pid --daemon
     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

kallithea/i18n/how_to

@@ -1,92 +1,92 b''
 ============
 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
 --------------------
 
-Edit test.ini file and set lang attribute to::
+Edit kallithea/tests/test.ini file and set lang attribute to::
 
     lang=<new_language_code>
 
 Run Kallithea tests by executing::
 
     nosetests

kallithea/tests/conftest.py

@@ -1,34 +1,34 b''
 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)
-    pylons.test.pylonsapp = loadapp('config:test.ini', relative_to=path)
+    pylons.test.pylonsapp = loadapp('config:kallithea/tests/test.ini', relative_to=path)
     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

kallithea/tests/other/manual_test_vcs_operations.py

@@ -1,537 +1,537 b''
 # -*- 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::
- paster serve test.ini
+ paster serve kallithea/tests/test.ini
  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 ǝɯɐᴎ <[e-mail]>'
         if vcs == 'hg':
             cmd = """hg commit -m 'commited new %s' -u '%s' %s """ % (
                 i, author_str, added_file
             )
         elif vcs == 'git':
             cmd = """EMAIL="[e-mail]" 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)
             # The message apparently changed in Git 1.8.3, so match it loosely.
             assert re.search(r'\b403\b', stderr)
         finally:
             #release IP restrictions
             for ip in UserIpMap.getAll():
                 UserIpMap.delete(ip.ip_id)
             Session().commit()
 
         time.sleep(2)
         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 == ''

setup.cfg

@@ -1,52 +1,52 b''
 [egg_info]
 tag_build =
 tag_svn_revision = 0
 tag_date = 0
 
 [nosetests]
 verbose = True
 verbosity = 2
-with-pylons = test.ini
+with-pylons = kallithea/tests/test.ini
 detailed-errors = 1
 nologcapture = 1
 
 [pytest]
 # only look for tests in kallithea/tests
 python_files = kallithea/tests/**/test_*.py
 addopts =
     # --verbose
     # show extra test summary info as specified by chars (f)ailed, (E)error, (s)skipped, (x)failed, (X)passed, (w)warnings.
     -rfEsxXw
     # Shorter scrollbacks; less stuff to scroll through
     --tb=short
 
 [compile_catalog]
 domain = kallithea
 directory = kallithea/i18n
 statistics = true
 
 [extract_messages]
 add_comments = TRANSLATORS:
 output_file = kallithea/i18n/kallithea.pot
 msgid-bugs-address = [e-mail]
 copyright-holder = Various authors, licensing as GPLv3
 no-wrap = true
 
 [init_catalog]
 domain = kallithea
 input_file = kallithea/i18n/kallithea.pot
 output_dir = kallithea/i18n
 
 [update_catalog]
 domain = kallithea
 input_file = kallithea/i18n/kallithea.pot
 output_dir = kallithea/i18n
 previous = true
 
 [build_sphinx]
 source-dir = docs/
 build-dir = docs/_build
 all_files = 1
 
 [upload_sphinx]
 upload-dir = docs/_build/html