UserGroupModel().add_user_to_group(user_group=gr,

                                       user=TEST_USER_ADMIN_LOGIN)

    Session().commit()

    return gr

def make_repo_group(name=TEST_REPO_GROUP):

    gr = fixture.create_repo_group(name, cur_user=TEST_USER_ADMIN_LOGIN)

    Session().commit()

    return gr

    REPO = None

    REPO_TYPE = None

    @classmethod

    def setup_class(cls):

        cls.usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)

        cls.apikey = cls.usr.api_key

        cls.test_user = UserModel().create_or_update(

            username='test-api',

            password='test',

            email='test@example.com',

            firstname='first',

# 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 import *

    REPO = GIT_REPO

    REPO_TYPE = 'git'

# 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 import *

    REPO = HG_REPO

    REPO_TYPE = 'hg'

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

    """

    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

                                                repo_description=description,

                                                _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               'Error creating repository %s' % repo_name)

        # repo must not be in db

        repo = Repository.get_by_repo_name(repo_name)

        self.assertEqual(repo, None)

        # repo must not be in filesystem !

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

    REPO = GIT_REPO

    REPO_TYPE = 'git'

    NEW_REPO = NEW_GIT_REPO

    OTHER_TYPE_REPO = HG_REPO

    OTHER_TYPE = 'hg'

    REPO = HG_REPO

    REPO_TYPE = 'hg'

    NEW_REPO = NEW_HG_REPO

    OTHER_TYPE_REPO = GIT_REPO

    OTHER_TYPE = 'git'

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

from kallithea.tests import *

from kallithea.tests.fixture import Fixture

from kallithea.model.db import Repository

from kallithea.model.repo import RepoModel

from kallithea.model.user import UserModel

from kallithea.model.meta import Session

fixture = Fixture()

from kallithea.tests import *

    @classmethod

    def setup_class(cls):

        pass

    @classmethod

    def teardown_class(cls):

        pass

    def setUp(self):

        self.username = u'forkuser'

        self.password = u'qweqwe'

        self.u1 = fixture.create_user(self.username, password=self.password,

                                      email=u'fork_king@example.com')

        Session().commit()

    def tearDown(self):

        Session().delete(self.u1)

        Session().commit()

    def test_index(self):

        self.log_user()

        repo_name = self.REPO

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

                                    repo_name=repo_name))

        response.mustcontain("""There are no forks yet""")

    def test_no_permissions_to_fork(self):

        usr = self.log_user(TEST_USER_REGULAR_LOGIN,

                            TEST_USER_REGULAR_PASS)['user_id']

        user_model = UserModel()

        self.assertEqual(1, len(forks))

        # set none

        RepoModel().grant_user_permission(repo=forks[0],

                                          user=usr, perm='repository.none')

        Session().commit()

        # fork shouldn't be there

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

                                    repo_name=repo_name))

        response.mustcontain('There are no forks yet')

    REPO = GIT_REPO

    NEW_REPO = NEW_GIT_REPO

    REPO_TYPE = 'git'

    REPO_FORK = GIT_FORK

    REPO = HG_REPO

    NEW_REPO = NEW_HG_REPO

    REPO_TYPE = 'hg'

    REPO_FORK = HG_FORK

"""

import os

import time

import shutil

import datetime

from kallithea.tests.vcs.conf import SCM_TESTS, get_new_dir

from kallithea.lib import vcs

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

from kallithea.lib.vcs.nodes import FileNode

    """

    This is a backend independent test case class which should be created

    with ``type`` method.

    It is required to set following attributes at subclass:

    - ``backend_alias``: alias of used backend (see ``vcs.BACKENDS``)

    - ``repo_path``: path to the repository which would be created for set of

      tests

    - ``recreate_repo_per_test``: If set to ``False``, repo would NOT be created

      before every single test. Defaults to ``True``.

    """

    def tearDown(self):

        if getattr(self, 'recreate_repo_per_test', False) and \

            'VCS_REMOVE_TEST_DIRS' in os.environ:

            shutil.rmtree(self.repo_path)

# For each backend create test case class

for alias in SCM_TESTS:

    attrs = {

        'backend_alias': alias,

    }

    cls_name = ''.join(('%s base backend test' % alias).title().split())

    globals()[cls_name] = type(cls_name, bases, attrs)

if __name__ == '__main__':

    unittest.main()

from __future__ import with_statement

import os

import tarfile

import zipfile

import datetime

import tempfile

import StringIO

from kallithea.tests.vcs.conf import SCM_TESTS

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.nodes import FileNode

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

    @classmethod

    def _get_commits(cls):

        start_date = datetime.datetime(2010, 1, 1, 20)

        for x in xrange(5):

            yield {

                'message': 'Commit %d' % x,

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': start_date + datetime.timedelta(hours=12 * x),

                'added': [

                    FileNode('%d/file_%d.txt' % (x, x),

                        content='Foobar %d' % x),

from __future__ import with_statement

import datetime

from kallithea.lib import vcs

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

from kallithea.lib.vcs.nodes import FileNode

from kallithea.tests.vcs.conf import SCM_TESTS

    @classmethod

    def _get_commits(cls):

        commits = [

            {

                'message': 'Initial commit',

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': datetime.datetime(2010, 1, 1, 20),

                'added': [

                    FileNode('foobar', content='Foobar'),

                    FileNode('foobar2', content='Foobar II'),

                    FileNode('foo/bar/baz', content='baz here!'),

# encoding: utf8

from __future__ import with_statement

import time

import datetime

from kallithea.lib import vcs

from kallithea.tests.vcs.conf import SCM_TESTS

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

from kallithea.lib.vcs.nodes import (

    FileNode, AddedFileNodesGenerator,

    ChangedFileNodesGenerator, RemovedFileNodesGenerator

)

from kallithea.lib.vcs.exceptions import (

    BranchDoesNotExistError, ChangesetDoesNotExistError,

    RepositoryError, EmptyRepositoryError

)

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

            'revision': 1009,

            'date': datetime.datetime(2011, 1, 30, 1, 45),

            'message': 'Message of a commit',

            'author': {

                'name': 'Joe Doe',

                'email': 'joe.doe@example.com',

            },

            'added': ['foo/bar/baz', 'foobar'],

            'changed': [],

            'removed': [],

        })

    recreate_repo_per_test = True

    @classmethod

    def _get_commits(cls):

        start_date = datetime.datetime(2010, 1, 1, 20)

        for x in xrange(5):

            yield {

                'message': 'Commit %d' % x,

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': start_date + datetime.timedelta(hours=12 * x),

                'added': [

                    FileNode('file_%d.txt' % x, content='Foobar %d' % x),

    def test_get_changeset_parents(self):

        for test_rev in [1, 2, 3]:

            sha = self.repo.get_changeset(test_rev-1)

            self.assertEqual([sha], self.repo.get_changeset(test_rev).parents)

    def test_get_changeset_children(self):

        for test_rev in [1, 2, 3]:

            sha = self.repo.get_changeset(test_rev+1)

            self.assertEqual([sha], self.repo.get_changeset(test_rev).children)

    recreate_repo_per_test = False

    @classmethod

    def _get_commits(cls):

        start_date = datetime.datetime(2010, 1, 1, 20)

        for x in xrange(5):

            yield {

                'message': u'Commit %d' % x,

                'author': u'Joe Doe <joe.doe@example.com>',

                'date': start_date + datetime.timedelta(hours=12 * x),

                'added': [

                    FileNode('file_%d.txt' % x, content='Foobar %d' % x),

    def test_get_changesets_numerical_id_respects_both_start_and_end_last(self):

        with self.assertRaises(RepositoryError):

            last = len(self.repo.revisions)

            list(self.repo.get_changesets(start=last-1, end=last-2))

    def test_get_changesets_numerical_id_last_zero_error(self):

        with self.assertRaises(RepositoryError):

            last = len(self.repo.revisions)

            list(self.repo.get_changesets(start=last-1, end=0))

    recreate_repo_per_test = False

    @classmethod

    def _get_commits(cls):

        return [

            {

                'message': u'Initial',

                'author': u'Joe Doe <joe.doe@example.com>',

                'date': datetime.datetime(2010, 1, 1, 20),

                'added': [

                    FileNode('foo/bar', content='foo'),

                    FileNode('foo/bał', content='foo'),

    def test_get_filemode_non_ascii(self):

        changeset = self.repo.get_changeset()

        self.assertEqual(33188, changeset.get_file_mode('foo/bał'))

        self.assertEqual(33188, changeset.get_file_mode(u'foo/bał'))

# For each backend create test case class

for alias in SCM_TESTS:

    attrs = {

        'backend_alias': alias,

    }

    # tests with additional commits

    cls_name = ''.join(('%s changesets with commits test' % alias).title().split())

    globals()[cls_name] = type(cls_name, bases, attrs)

    # tests without additional commits

    cls_name = ''.join(('%s changesets test' % alias).title().split())

    globals()[cls_name] = type(cls_name, bases, attrs)

    # tests changes

    cls_name = ''.join(('%s changesets changes test' % alias).title().split())

    globals()[cls_name] = type(cls_name, bases, attrs)

if __name__ == '__main__':

    unittest.main()

from __future__ import with_statement

import datetime

from kallithea.tests.vcs.conf import SCM_TESTS

from kallithea.lib.vcs.nodes import FileNode

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

    @classmethod

    def _get_commits(cls):

        start_date = datetime.datetime(2010, 1, 1, 20)

        for x in xrange(5):

            yield {

                'message': 'Commit %d' % x,

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': start_date + datetime.timedelta(hours=12 * x),

                'added': [

                    FileNode('file_%d.txt' % x, content='Foobar %d' % x),

                ],

from __future__ import with_statement

import datetime

from kallithea.tests.vcs.conf import SCM_TESTS

from kallithea.lib.vcs.nodes import FileNode

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

    @classmethod

    def _get_commits(cls):

        start_date = datetime.datetime(2010, 1, 1, 20)

        for x in xrange(5):

            yield {

                'message': 'Commit %d' % x,

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': start_date + datetime.timedelta(hours=12 * x),

                'added': [

                    FileNode('file_%d.txt' % x, content='Foobar %d' % x),

                ],

from __future__ import with_statement

import os

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.tests.vcs.conf import TEST_GIT_REPO, TEST_GIT_REPO_CLONE, get_new_dir

class GitRepositoryTest(unittest.TestCase):

    def __check_for_existing_repo(self):

        if os.path.exists(TEST_GIT_REPO_CLONE):

            self.fail('Cannot test git clone repo as location %s already '

                      'exists. You should manually remove it first.'

                      % TEST_GIT_REPO_CLONE)

    def setUp(self):

        changeset._diff_name_status = 'foobar'

        with self.assertRaises(VCSError):

            changeset.added

    def test_error_is_raised_for_removed_if_diff_name_status_is_wrong(self):

        repo = mock.MagicMock()

        changeset = GitChangeset(repo, 'foobar')

        changeset._diff_name_status = 'foobar'

        with self.assertRaises(VCSError):

            changeset.added

    backend_alias = 'git'

    @classmethod

    def _get_commits(cls):

        return [

            {

                'message': 'Initial',

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': datetime.datetime(2010, 1, 1, 20),

                'added': [

                    FileNode('foobar/static/js/admin/base.js', content='base'),

                    FileNode('foobar/static/admin', content='admin',

        self.repo.run_git_command.assert_called_once_with(

            'show -U%s --full-index --binary -p -M --abbrev=40 %s' %

            (3, self.repo._get_revision(1)))

    def test_get_diff_runs_git_command_with_path_if_its_given(self):

        self.repo.run_git_command = mock.Mock(return_value=['', ''])

        self.repo.get_diff(0, 1, 'foo')

        self.repo.run_git_command.assert_called_once_with(

          'diff -U%s --full-index --binary -p -M --abbrev=40 %s %s -- "foo"'

            % (3, self.repo._get_revision(0), self.repo._get_revision(1)))

    backend_alias = 'git'

    @classmethod

    def _get_commits(cls):

        return [

            {

                'message': 'Initial',

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': datetime.datetime(2010, 1, 1, 20),

                'added': [

                    FileNode('bot/__init__.py', content='base'),

                    FileNode('bot/templates/404.html', content='base'),

from __future__ import with_statement

import datetime

from kallithea.tests.vcs.conf import SCM_TESTS

from kallithea.tests.vcs.conf import TEST_USER_CONFIG_FILE

from kallithea.lib.vcs.nodes import FileNode

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

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError

    recreate_repo_per_test = False

    @classmethod

    def _get_commits(cls):

        return super(RepositoryBaseTest, cls)._get_commits()[:1]

    def test_get_config_value(self):

        self.assertEqual(self.repo.get_config_value('universal', 'foo',

            TEST_USER_CONFIG_FILE), 'bar')

    def test_get_config_value_defaults_to_None(self):

        self.assertEqual(self.repo.get_config_value('universal', 'nonexist',

    def test_repo_equality_broken_object(self):

        import copy

        _repo = copy.copy(self.repo)

        delattr(_repo, 'path')

        self.assertTrue(self.repo != _repo)

    def test_repo_equality_other_object(self):

        class dummy(object):

            path = self.repo.path

        self.assertTrue(self.repo != dummy())

    @classmethod

    def _get_commits(cls):

        commits = [

            {

                'message': 'Initial commit',

                'author': 'Joe Doe <joe.doe@example.com>',

                'date': datetime.datetime(2010, 1, 1, 20),

                'added': [

                    FileNode('foobar', content='foobar'),

                    FileNode('foobar2', content='foobar2'),

                ],

from __future__ import with_statement

from kallithea.tests.vcs.conf import SCM_TESTS

from kallithea.lib.vcs.exceptions import TagAlreadyExistError

from kallithea.lib.vcs.exceptions import TagDoesNotExistError

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

    def test_new_tag(self):

        tip = self.repo.get_changeset()

        tagsize = len(self.repo.tags)

        tag = self.repo.tag('last-commit', 'joe', tip.raw_id)

        self.assertEqual(len(self.repo.tags), tagsize + 1)

        for top, dirs, files in tip.walk():

            self.assertEqual(top, tag.get_node(top.path))

    def test_tag_already_exist(self):

        tip = self.repo.get_changeset()

from __future__ import with_statement

import datetime

from kallithea.lib.vcs.nodes import FileNode

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

from kallithea.tests.vcs.conf import SCM_TESTS

    @classmethod

    def _get_commits(cls):

        commits = [

            {

                'message': u'Initial commit',

                'author': u'Joe Doe <joe.doe@example.com>',

                'date': datetime.datetime(2010, 1, 1, 20),

                'added': [

                    FileNode('foobar', content='Foobar'),

                    FileNode('foobar2', content='Foobar II'),

                    FileNode('foo/bar/baz', content='baz here!'),