- see ``conf`` module for more detail. We simply try to check if repository at

certain location exists, if not we would try to fetch them. At ``test_vcs`` or

``test_common`` we run unit tests common for each repository type and for

example specific mercurial tests are located at ``test_hg`` module.

Oh, and tests are run with ``unittest.collector`` wrapped by ``collector``

function at ``tests/__init__.py``.

.. _vcs: http://bitbucket.org/marcinkuzminski/vcs

.. _unittest: http://pypi.python.org/pypi/unittest

"""

from kallithea.tests.vcs.conf import *

from kallithea.tests.vcs.utils import SCMFetcher

from kallithea.tests.base import *

def setup_package():

    """

    Prepares whole package for tests which mainly means it would try to fetch

    test repositories or use already existing ones.

    """

    fetchers = {

        },

        'git': {

            'alias': 'git',

            'test_repo_path': TEST_GIT_REPO,

            'remote_repo': GIT_REMOTE_REPO,

            'clone_cmd': 'git clone --bare',

        },

    }

    for scm, fetcher_info in fetchers.items():

        fetcher = SCMFetcher(**fetcher_info)

        fetcher.setup()

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

    bases = (_BackendTestMixin, unittest.TestCase)

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

        with self.assertRaises(VCSError):

            self.tip.fill_archive(prefix='/any')

# For each backend create test case class

for alias in SCM_TESTS:

    attrs = {

        'backend_alias': alias,

    }

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

    bases = (ArchivesTestCaseMixin, unittest.TestCase)

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

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.base import _BackendTestMixin

from kallithea.tests.vcs.conf import SCM_TESTS

class BranchesTestCaseMixin(_BackendTestMixin):

    @classmethod

        self.assertIn('issue/123', self.repo.branches)

        self.assertIn('123', self.repo.branches)

# For each backend create test case class

for alias in SCM_TESTS:

    attrs = {

        'backend_alias': alias,

    }

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

    bases = (BranchesTestCaseMixin, unittest.TestCase)

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

    bases = (_ChangesetsWithCommitsTestCaseixin, unittest.TestCase)

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

    # tests without additional commits

    cls_name = alias.title() + 'ChangesetsTest'

    bases = (_ChangesetsTestCaseMixin, unittest.TestCase)

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

    # tests changes

    cls_name = alias.title() + 'ChangesetsChangesTest'

    bases = (_ChangesetsChangesTestCaseMixin, unittest.TestCase)

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

# encoding: utf8

import datetime

from kallithea.lib.vcs.nodes import FileNode

from kallithea.tests.vcs.test_inmemchangesets import BackendBaseTestCase

from kallithea.tests.vcs.conf import SCM_TESTS

class FileNodeUnicodePathTestsMixin(object):

    fname = 'ąśðąęłąć.txt'

    ufname = (fname).decode('utf-8')

    def get_commits(self):

        self.nodes = [

            FileNode(self.fname, content='Foobar'),

        unode = self.tip.get_node(self.ufname)

        self.assertEqual(node, unode)

for alias in SCM_TESTS:

    attrs = {

        'backend_alias': alias,

    }

    cls_name = ''.join(('%s file node unicode path test' % alias).title()

        .split())

    bases = (FileNodeUnicodePathTestsMixin, BackendBaseTestCase)

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

import datetime

from kallithea.tests.vcs.base import _BackendTestMixin

from kallithea.tests.vcs.conf import SCM_TESTS

from kallithea.lib.vcs.nodes import FileNode

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

class GetitemTestCaseMixin(_BackendTestMixin):

    @classmethod

    def _get_commits(cls):

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

        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:

    attrs = {

        'backend_alias': alias,

    }

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

    bases = (GetitemTestCaseMixin, unittest.TestCase)

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

import datetime

from kallithea.tests.vcs.base import _BackendTestMixin

from kallithea.tests.vcs.conf import SCM_TESTS

from kallithea.lib.vcs.nodes import FileNode

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

class GetsliceTestCaseMixin(_BackendTestMixin):

    @classmethod

    def _get_commits(cls):

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

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

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

# For each backend create test case class

for alias in SCM_TESTS:

    attrs = {

        'backend_alias': alias,

    }

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

    bases = (GetsliceTestCaseMixin, unittest.TestCase)

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

import os

import sys

import mock

import datetime

import urllib2

import pytest

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

        Tests if hooks are forcefully updated even though they are custom hooks.

        """

        for hook, hook_path in self.kallithea_hooks.iteritems():

            with open(hook_path, "w") as f:

                f.write("#!/bin/bash\n#CUSTOM_HOOK")

        ScmModel().install_git_hooks(repo=self.repo, force_create=True)

        for hook, hook_path in self.kallithea_hooks.iteritems():

            with open(hook_path) as f:

                self.assertIn("KALLITHEA_HOOK_VER", f.read())

import os

import pytest

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

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

        self.tip = self.repo.get_changeset()

# For each backend create test case class

for alias in SCM_TESTS:

    attrs = {

        'backend_alias': alias,

    }

    cls_name = ''.join(('%s in memory changeset test' % alias).title().split())

    bases = (InMemoryChangesetTestMixin, unittest.TestCase)

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

import stat

import mimetypes

from kallithea.lib.vcs.nodes import DirNode

from kallithea.lib.vcs.nodes import FileNode

from kallithea.lib.vcs.nodes import Node

from kallithea.lib.vcs.nodes import NodeError

from kallithea.lib.vcs.nodes import NodeKind

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

class NodeBasicTest(unittest.TestCase):

        self.assertEqual(my_node2.get_mimetype(), ('text/plain', None))

        self.assertEqual(my_node3.mimetype, 'application/octet-stream')

        self.assertEqual(my_node3.get_mimetype(), ('application/octet-stream', None))

class NodeContentTest(unittest.TestCase):

    def test_if_binary(self):

        data = """\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f??a\x00\x00\x00\x04gAMA\x00\x00\xaf?7\x05\x8a?\x00\x00\x00\x19tEXtSoftware\x00Adobe ImageReadyq?e<\x00\x00\x025IDAT8?\xa5\x93?K\x94Q\x14\x87\x9f\xf7?Q\x1bs4?\x03\x9a\xa8?B\x02\x8b$\x10[U;i\x13?6h?&h[?"\x14j?\xa2M\x7fB\x14F\x9aQ?&\x842?\x0b\x89"\x82??!?\x9c!\x9c2l??{N\x8bW\x9dY\xb4\t/\x1c?=\x9b?}????\xa9*;9!?\x83\x91?[?\\v*?D\x04\'`EpNp\xa2X\'U?pVq"Sw.\x1e?\x08\x01D?jw????\xbc??7{|\x9b?\x89$\x01??W@\x15\x9c\x05q`Lt/\x97?\x94\xa1d?\x18~?\x18?\x18W[%\xb0?\x83??\x14\x88\x8dB?\xa6H\tL\tl\x19>/\x01`\xac\xabx?\x9cl\nx\xb0\x98\x07\x95\x88D$"q[\x19?d\x00(o\n\xa0??\x7f\xb9\xa4?\x1bF\x1f\x8e\xac\xa8?j??eUU}?.?\x9f\x8cE??x\x94??\r\xbdtoJU5"0N\x10U?\x00??V\t\x02\x9f\x81?U?\x00\x9eM\xae2?r\x9b7\x83\x82\x8aP3????.?&"?\xb7ZP \x0c<?O\xa5\t}\xb8?\x99\xa6?\x87?\x1di|/\xa0??0\xbe\x1fp?d&\x1a\xad\x95\x8a\x07?\t*\x10??b:?d?.\x13C\x8a?\x12\xbe\xbf\x8e?{???\x08?\x80\xa7\x13+d\x13>J?\x80\x15T\x95\x9a\x00??S\x8c\r?\xa1\x03\x07?\x96\x9b\xa7\xab=E??\xa4\xb3?\x19q??B\x91=\x8d??k?J\x0bV"??\xf7x?\xa1\x00?\\.\x87\x87???\x02F@D\x99],??\x10#?X\xb7=\xb9\x10?Z\x1by???cI??\x1ag?\x92\xbc?T?t[\x92\x81?<_\x17~\x92\x88?H%?\x10Q\x02\x9f\n\x81qQ\x0bm?\x1bX?\xb1AK\xa6\x9e\xb9?u\xb2?1\xbe|/\x92M@\xa2!F?\xa9>"\r<DT?>\x92\x8e?>\x9a9Qv\x127?a\xac?Y?8?:??]X???9\x80\xb7?u?\x0b#BZ\x8d=\x1d?p\x00\x00\x00\x00IEND\xaeB`\x82"""

        filenode = FileNode('calendar.png', content=data)

        self.assertTrue(filenode.is_binary)

+FOOBAR

''')

# For each backend create test case class

for alias in SCM_TESTS:

    attrs = {

        'backend_alias': alias,

    }

    cls_name = alias.capitalize() + RepositoryBaseTest.__name__

    bases = (RepositoryBaseTest, unittest.TestCase)

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

from kallithea.tests.vcs.base import _BackendTestMixin

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

class TagsTestCaseMixin(_BackendTestMixin):

    def test_new_tag(self):

        tip = self.repo.get_changeset()

        tagsize = len(self.repo.tags)

        self.repo.tag('19/10/11', 'joe')

        self.assertTrue('19/10/11' in self.repo.tags)

# For each backend create test case class

for alias in SCM_TESTS:

    attrs = {

        'backend_alias': alias,

    }

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

    bases = (TagsTestCaseMixin, unittest.TestCase)

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

    @mock.patch.object(os, 'environ', {'HOME': '/home/foobar'})

    def test_unix_like(self):

        self.assertEqual(get_user_home(), '/home/foobar')

    @mock.patch.object(os, 'environ', {'USERPROFILE': '/Users/foobar'})

    def test_windows_like(self):

        self.assertEqual(get_user_home(), '/Users/foobar')

    @mock.patch.object(os, 'environ', {'HOME': '/home/foobar',

        'USERPROFILE': '/Users/foobar'})

    def test_prefers_home_over_userprofile(self):

        self.assertEqual(get_user_home(), '/home/foobar')

from kallithea.lib.vcs.utils.filesize import filesizeformat

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

class TestFilesizeformat(unittest.TestCase):

    def test_bytes(self):

        self.assertEqual(filesizeformat(10), '10 B')

    def test_kilobytes(self):

        self.assertEqual(filesizeformat(1024 * 2), '2 KB')

    def test_megabytes(self):

        self.assertEqual(filesizeformat(1024 * 1024 * 2.3), '2.3 MB')

    def test_gigabytes(self):

        self.assertEqual(filesizeformat(1024 * 1024 * 1024 * 12.92), '12.92 GB')

    def test_that_function_respects_sep_parameter(self):

        self.assertEqual(filesizeformat(1, ''), '1B')

import datetime

from kallithea.lib.vcs.nodes import FileNode

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

from kallithea.tests.vcs.base import _BackendTestMixin

from kallithea.tests.vcs.conf import SCM_TESTS

class WorkdirTestCaseMixin(_BackendTestMixin):

    @classmethod

    def _get_commits(cls):

        commits = [

        self.repo.workdir.checkout_branch('foobranch')

        self.assertEqual(self.repo.workdir.get_branch(), 'foobranch')

# For each backend create test case class

for alias in SCM_TESTS:

    attrs = {

        'backend_alias': alias,

    }

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

    bases = (WorkdirTestCaseMixin, unittest.TestCase)

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