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

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

        # 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):

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

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

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

import os

import sys

import mock

import datetime

import urllib2

from kallithea.lib.vcs.backends.git import GitRepository, GitChangeset

from kallithea.lib.vcs.exceptions import RepositoryError, VCSError, NodeDoesNotExistError

from kallithea.lib.vcs.nodes import NodeKind, FileNode, DirNode, NodeState

from kallithea.lib.vcs.utils.compat import unittest

from kallithea.model.scm import ScmModel

from kallithea.tests.vcs.base import _BackendTestMixin

class GitRepositoryTest(unittest.TestCase):

    def __check_for_existing_repo(self):

        if os.path.exists(TEST_GIT_REPO_CLONE):

                      'exists. You should manually remove it first.'

                      % TEST_GIT_REPO_CLONE)

    def setUp(self):

        self.repo = GitRepository(TEST_GIT_REPO)

        idx = 0

        for changeset in changesets:

            rev = offset + idx

            idx += 1

            rev_id = self.repo.revisions[rev]

            if idx > limit:

                    "there are %s total revisions, offset=%s, limit=%s)"

                    % (rev_id, count, offset, limit))

            self.assertEqual(changeset, self.repo.get_changeset(rev_id))

        result = list(self.repo.get_changesets(limit=limit, offset=offset))

        start = offset

        end = limit and offset + limit or None

        sliced = list(self.repo[start:end])

            msg="Comparison failed for limit=%s, offset=%s"

            "(get_changeset returned: %s and sliced: %s"

            % (limit, offset, result, sliced))

    def _test_file_size(self, revision, path, size):

        node = self.repo.get_changeset(revision).get_node(path)

import os

from kallithea.lib.utils2 import safe_str

from kallithea.lib.vcs.backends.hg import MercurialRepository, MercurialChangeset

from kallithea.lib.vcs.exceptions import RepositoryError, VCSError, NodeDoesNotExistError

from kallithea.lib.vcs.nodes import NodeKind, NodeState

from kallithea.tests.vcs.conf import TEST_HG_REPO, TEST_HG_REPO_CLONE, \

    TEST_HG_REPO_PULL

class MercurialRepositoryTest(unittest.TestCase):

    def __check_for_existing_repo(self):

        if os.path.exists(TEST_HG_REPO_CLONE):

                      'exists. You should manually remove it first.'

                      % TEST_HG_REPO_CLONE)

    def setUp(self):

        self.repo = MercurialRepository(safe_str(TEST_HG_REPO))

        self.assertEqual(os.path.isfile(os.path.join(TEST_HG_REPO_CLONE \

                                                    + '_wo_update',

                                                    'MANIFEST.in')), False,)

    def test_pull(self):

        if os.path.exists(TEST_HG_REPO_PULL):

                      'already exists. You should manually remove it first'

                      % TEST_HG_REPO_PULL)

        repo_new = MercurialRepository(TEST_HG_REPO_PULL, create=True)

        self.assertTrue(len(self.repo.revisions) > len(repo_new.revisions))

        repo_new.pull(self.repo.path)

        for node_path, expected_parent_path in test_paths:

            self._test_parent_path(node_path, expected_parent_path)

    '''

    def _test_trailing_slash(self, path):

        if not path.endswith('/'):

        for kind in NodeKind.FILE, NodeKind.DIR:

            self.assertRaises(NodeError, Node, path=path, kind=kind)

    def test_trailing_slash(self):

        for path in ('/', 'foo/', 'foo/bar/', 'foo/bar/biz/'):

            self._test_trailing_slash(path)