raise Exception('Total Crash !')

def api_call(test_obj, params):

    response = test_obj.app.post(API_URL, content_type='application/json',

                                 params=params)

    return response

## helpers

def make_user_group(name=TEST_USER_GROUP):

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

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

            lastname='last'

        )

        Session().commit()

        cls.TEST_USER_LOGIN = cls.test_user.username

        cls.apikey_regular = cls.test_user.api_key

    @classmethod

    def teardown_class(cls):

        pass

    def setUp(self):

        self.maxDiff = None

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

    REPO = GIT_REPO

    REPO_TYPE = 'git'

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

    REPO = HG_REPO

    REPO_TYPE = 'hg'

import urllib

from kallithea.lib import vcs

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

    Permission

from kallithea.model.user import UserModel

from kallithea.tests import *

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

                .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

    @classmethod

    def teardown_class(cls):

        pass

    def test_index(self):

        self.log_user()

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

    def test_create(self):

        self.log_user()

        repo_name = self.NEW_REPO

        Session().commit()

    @mock.patch.object(RepoModel, '_create_filesystem_repo', error_function)

    def test_create_repo_when_filesystem_op_fails(self):

        self.log_user()

        repo_name = self.NEW_REPO

        description = 'description for newly created repo'

        response = self.app.post(url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

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

        user_model.revoke_perm(usr, 'hg.fork.repository')

        user_model.grant_perm(usr, 'hg.fork.none')

        u = UserModel().get(usr)

        u.inherit_default_permissions = False

        Session().commit()

        # try create a fork

        repo_name = self.REPO

        self.app.post(url(controller='forks', action='fork_create',

                          repo_name=repo_name), {'_authentication_token': self.authentication_token()}, status=403)

    def test_index_with_fork(self):

        self.log_user()

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

                                    repo_name=repo_name))

        response.mustcontain('<div style="padding:5px 3px 3px 42px;">fork of vcs test</div>')

    def test_zzz_fork_permission_page(self):

        usr = self.log_user(self.username, self.password)['user_id']

        repo_name = self.REPO

        forks = Repository.query()\

            .filter(Repository.repo_type == self.REPO_TYPE)\

            .filter(Repository.fork_id != None).all()

        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

"""

Module providing backend independent mixin class. It requires that

InMemoryChangeset class is working properly at backend class.

"""

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``.

    """

    recreate_repo_per_test = True

    @classmethod

    def get_backend(cls):

        return vcs.get_backend(cls.backend_alias)

    @classmethod

    def _get_commits(cls):

        commits = [

            {

                'message': u'Initial commit',

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

                                     date=commit['date'])

    @classmethod

    def tearDownClass(cls):

        if not getattr(cls, 'recreate_repo_per_test', False) and \

            'VCS_REMOVE_TEST_DIRS' in os.environ:

            shutil.rmtree(cls.repo_path)

    def setUp(self):

        if getattr(self, 'recreate_repo_per_test', False):

            self.__class__.setUpClass()

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

                ],

            }

    def test_archive_zip(self):

        path = tempfile.mkstemp()[1]

        with open(path, 'wb') as f:

            self.tip.fill_archive(stream=f, kind='zip', prefix='repo')

        out = zipfile.ZipFile(path)

        for x in xrange(5):

            node_path = '%d/file_%d.txt' % (x, x)

            decompressed = StringIO.StringIO()

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

                ],

            },

            {

                'message': 'Changes...',

                'author': 'Jane Doe <jane.doe@example.com>',

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

                'added': [

                    FileNode('some/new.txt', content='news...'),

                ],

                'changed': [

                    FileNode('foobar', 'Foobar I'),

                ],

# 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

from kallithea.tests.vcs.conf import get_new_dir

class TestBaseChangeset(unittest.TestCase):

    def test_as_dict(self):

        changeset = BaseChangeset()

        changeset.id = 'ID'

        changeset.raw_id = 'RAW_ID'

        changeset.short_id = 'SHORT_ID'

        changeset.revision = 1009

        changeset.date = datetime.datetime(2011, 1, 30, 1, 45)

        changeset.message = 'Message of a commit'

        changeset.author = 'Joe Doe <joe.doe@example.com>'

        changeset.added = [FileNode('foo/bar/baz'), FileNode('foobar')]

        changeset.changed = []

        changeset.removed = []

        self.assertEqual(changeset.as_dict(), {

            'id': 'ID',

            'raw_id': 'RAW_ID',

            'short_id': 'SHORT_ID',

            '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_new_branch(self):

        self.imc.add(vcs.nodes.FileNode('docs/index.txt',

            content='Documentation\n'))

        foobar_tip = self.imc.commit(

            message=u'New branch: foobar',

            author=u'joe',

            branch='foobar',

        )

        self.assertTrue('foobar' in self.repo.branches)

        )

        default_branch_changesets = self.repo.get_changesets(

            branch_name=self.repo.DEFAULT_BRANCH_NAME)

        self.assertNotIn(doc_changeset, default_branch_changesets)

    def test_get_changeset_by_branch(self):

        for branch, sha in self.repo.branches.iteritems():

            self.assertEqual(sha, self.repo.get_changeset(branch).raw_id)

    def test_get_changeset_by_tag(self):

        for tag, sha in self.repo.tags.iteritems():

            self.assertEqual(sha, self.repo.get_changeset(tag).raw_id)

    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_simple(self):

        tip = self.repo.get_changeset()

        self.assertEqual(tip.date, datetime.datetime(2010, 1, 3, 20))

    def test_get_changesets_is_ordered_by_date(self):

        changesets = list(self.repo.get_changesets())

        ordered_by_date = sorted(changesets,

            key=lambda cs: cs.date)

        self.assertItemsEqual(changesets, ordered_by_date)

        with self.assertRaises(BranchDoesNotExistError):

            list(self.repo.get_changesets(branch_name='foobar'))

    def test_get_changesets_raise_repositoryerror_for_wrong_start_end(self):

        start = self.repo.revisions[-1]

        end = self.repo.revisions[0]

        with self.assertRaises(RepositoryError):

            list(self.repo.get_changesets(start=start, end=end))

    def test_get_changesets_numerical_id_reversed(self):

        with self.assertRaises(RepositoryError):

            [x for x in self.repo.get_changesets(start=3, end=2)]

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

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

                    FileNode('qwe', content='foo'),

                ],

            },

            {

                'message': u'Massive changes',

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

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

                'added': [FileNode('fallout', content='War never changes')],

                'changed': [

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

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

        self.assertItemsEqual(changeset.changed, [

            changeset.get_node('foo/bar'),

            changeset.get_node('foobar'),

        ])

        self.assertTrue(isinstance(changeset.removed, RemovedFileNodesGenerator))

        self.assertEqual(len(changeset.removed), 1)

        self.assertEqual(list(changeset.removed)[0].path, 'qwe')

    def test_get_filemode(self):

        changeset = self.repo.get_changeset()

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

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

                ],

            }

    def test__getitem__last_item_is_tip(self):

        self.assertEqual(self.repo[-1], self.repo.get_changeset())

    def test__getitem__returns_correct_items(self):

        changesets = [self.repo[x] for x in xrange(len(self.repo.revisions))]

        self.assertEqual(changesets, list(self.repo.get_changesets()))

# For each backend create test case class

for alias in SCM_TESTS:

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

                ],

            }

    def test__getslice__last_item_is_tip(self):

        self.assertEqual(list(self.repo[-1:])[0], self.repo.get_changeset())

    def test__getslice__respects_start_index(self):

        self.assertEqual(list(self.repo[2:]),

            [self.repo.get_changeset(rev) for rev in self.repo.revisions[2:]])

    def test__getslice__respects_negative_start_index(self):

        self.assertEqual(list(self.repo[-2:]),

            [self.repo.get_changeset(rev) for rev in self.repo.revisions[-2:]])

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

        self.repo = GitRepository(TEST_GIT_REPO)

    def test_wrong_repo_path(self):

        wrong_repo_path = '/tmp/errorrepo'

        self.assertRaises(RepositoryError, GitRepository, wrong_repo_path)

    def test_git_cmd_injection(self):

        repo_inject_path = TEST_GIT_REPO + '; echo "Cake";'

        with self.assertRaises(urllib2.URLError):

            # Should fail because URL will contain the parts after ; too

            urlerror_fail_repo = GitRepository(get_new_dir('injection-repo'), src_url=repo_inject_path, update_after_clone=True, create=True)

class GitSpecificTest(unittest.TestCase):

    def test_error_is_raised_for_added_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

    def test_error_is_raised_for_changed_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

    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 [