self._parsed_refs = self._get_parsed_refs()

            self.tags = self._get_tags()

        except OSError as e:

            raise RepositoryError(e.strerror)

    @LazyProperty

    def bookmarks(self):

        """

        Gets bookmarks for this repository

        """

        return {}

    @LazyProperty

    def _parsed_refs(self):

        return self._get_parsed_refs()

    def _get_parsed_refs(self):

        # cache the property

        _repo = self._repo

        refs = _repo.get_refs()

        keys = [('refs/heads/', 'H'),

                ('refs/remotes/origin/', 'RH'),

                ('refs/tags/', 'T')]

        _refs = {}

        for ref, sha in refs.iteritems():

            for k, type_ in keys:

                if ref.startswith(k):

                    _key = ref[len(k):]

                    if type_ == 'T':

                        obj = _repo.get_object(sha)

                        if isinstance(obj, Tag):

                            sha = _repo.get_object(sha).object[1]

                    _refs[_key] = [sha, type_]

                    break

        return _refs

    def _heads(self, reverse=False):

        refs = self._repo.get_refs()

        heads = {}

        for key, val in refs.items():

            for ref_key in ['refs/heads/', 'refs/remotes/origin/']:

                if key.startswith(ref_key):

                    n = key[len(ref_key):]

                    if n not in ['HEAD']:

                        heads[n] = val

        return heads if reverse else dict((y, x) for x, y in heads.iteritems())

    def get_changeset(self, revision=None):

        """

        Returns ``GitChangeset`` object representing commit from git repository

        at the given revision or head (most recent commit) if None given.

        """

        if isinstance(revision, GitChangeset):

            return revision

        revision = self._get_revision(revision)

        changeset = GitChangeset(repository=self, revision=revision)

        return changeset

    def get_changesets(self, start=None, end=None, start_date=None,

           end_date=None, branch_name=None, reverse=False, max_revisions=None):

        """

        Returns iterator of ``GitChangeset`` objects from start to end (both

        are inclusive), in ascending date order (unless ``reverse`` is set).

        :param start: changeset ID, as str; first returned changeset

        :param end: changeset ID, as str; last returned changeset

        :param start_date: if specified, changesets with commit date less than

          ``start_date`` would be filtered out from returned set

        :param end_date: if specified, changesets with commit date greater than

          ``end_date`` would be filtered out from returned set

        :param branch_name: if specified, changesets not reachable from given

          branch would be filtered out from returned set

        :param reverse: if ``True``, returned generator would be reversed

          (meaning that returned changesets would have descending date order)

        :raise BranchDoesNotExistError: If given ``branch_name`` does not

            exist.

        :raise ChangesetDoesNotExistError: If changeset for given ``start`` or

          ``end`` could not be found.

        """

        if branch_name and branch_name not in self.branches:

            raise BranchDoesNotExistError("Branch '%s' not found"

                                          % branch_name)

        # actually we should check now if it's not an empty repo to not spaw

        # subprocess commands

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        # %H at format means (full) commit hash, initial hashes are retrieved

        # in ascending date order

        cmd = ['log', '--date-order', '--reverse', '--pretty=format:%H']

        if max_revisions:

            cmd += ['--max-count=%s' % max_revisions]

        if start_date:

            cmd += ['--since', start_date.strftime('%m/%d/%y %H:%M:%S')]

        if end_date:

            cmd += ['--until', end_date.strftime('%m/%d/%y %H:%M:%S')]

        if branch_name:

            cmd.append(branch_name)

        else:

            cmd.append(settings.GIT_REV_FILTER)

        revs = self.run_git_command(cmd)[0].splitlines()

        start_pos = 0

        end_pos = len(revs)

        if start:

            _start = self._get_revision(start)

            try:

                start_pos = revs.index(_start)

            except ValueError:

                pass

        if end is not None:

            _end = self._get_revision(end)

            try:

                end_pos = revs.index(_end)

            except ValueError:

                pass

        if None not in [start, end] and start_pos > end_pos:

            raise RepositoryError('start cannot be after end')

        if end_pos is not None:

            end_pos += 1

        revs = revs[start_pos:end_pos]

        if reverse:

            revs.reverse()

        return CollectionGenerator(self, revs)

    def get_diff(self, rev1, rev2, path=None, ignore_whitespace=False,

                 context=3):

        """

        Returns (git like) *diff*, as plain text. Shows changes introduced by

        ``rev2`` since ``rev1``.

        :param rev1: Entry point from which diff is shown. Can be

          ``self.EMPTY_CHANGESET`` - in this case, patch showing all

          the changes since empty state of the repository until ``rev2``

        :param rev2: Until which revision changes should be shown.

        :param ignore_whitespace: If set to ``True``, would not show whitespace

          changes. Defaults to ``False``.

        :param context: How many lines before/after changed lines should be

          shown. Defaults to ``3``. Due to limitations in Git, if

          value passed-in is greater than ``2**31-1``

          (``2147483647``), it will be set to ``2147483647``

          instead. If negative value is passed-in, it will be set to

          ``0`` instead.

        """

        # Git internally uses a signed long int for storing context

        # size (number of lines to show before and after the

        # differences). This can result in integer overflow, so we

        # ensure the requested context is smaller by one than the

        # number that would cause the overflow. It is highly unlikely

        # that a single file will contain that many lines, so this

        # kind of change should not cause any realistic consequences.

        overflowed_long_int = 2**31

        if context >= overflowed_long_int:

            context = overflowed_long_int - 1

        # Negative context values make no sense, and will result in

        # errors. Ensure this does not happen.

        if context < 0:

            context = 0

        flags = ['-U%s' % context, '--full-index', '--binary', '-p', '-M', '--abbrev=40']

        if ignore_whitespace:

            flags.append('-w')

        if hasattr(rev1, 'raw_id'):

            rev1 = getattr(rev1, 'raw_id')

        if hasattr(rev2, 'raw_id'):

            rev2 = getattr(rev2, 'raw_id')

        if rev1 == self.EMPTY_CHANGESET:

            rev2 = self.get_changeset(rev2).raw_id

            cmd = ['show'] + flags + [rev2]

        else:

            rev1 = self.get_changeset(rev1).raw_id

            rev2 = self.get_changeset(rev2).raw_id

            cmd = ['diff'] + flags + [rev1, rev2]

        if path:

            cmd += ['--', path]

        # If we used 'show' command, strip first few lines (until actual diff

        # starts)

        if rev1 == self.EMPTY_CHANGESET:

            parts = stdout.split('\ndiff ', 1)

            if len(parts) > 1:

                stdout = 'diff ' + parts[1]

        return stdout

    @LazyProperty

    def in_memory_changeset(self):

        """

        Returns ``GitInMemoryChangeset`` object for this repository.

        """

        return GitInMemoryChangeset(self)

    def clone(self, url, update_after_clone=True, bare=False):

        """

        Tries to clone changes from external location.

        :param update_after_clone: If set to ``False``, git won't checkout

          working directory

        :param bare: If set to ``True``, repository would be cloned into

          *bare* git repository (no working directory at all).

        """

        url = self._get_url(url)

        cmd = ['clone', '-q']

        if bare:

            cmd.append('--bare')

        elif not update_after_clone:

            cmd.append('--no-checkout')

        cmd += ['--', url, self.path]

        # If error occurs run_git_command raises RepositoryError already

        self.run_git_command(cmd)

    def pull(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        cmd = ['pull', '--ff-only', url]

        # If error occurs run_git_command raises RepositoryError already

        self.run_git_command(cmd)

    def fetch(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        so, se = self.run_git_command(['ls-remote', '-h', url])

        cmd = ['fetch', url, '--']

        for line in (x for x in so.splitlines()):

            sha, ref = line.split('\t')

            cmd.append('+%s:%s' % (ref, ref))

        self.run_git_command(cmd)

    def _update_server_info(self):

        """

        runs gits update-server-info command in this repo instance

        """

        from dulwich.server import update_server_info

        try:

            update_server_info(self._repo)

        except OSError as e:

            if e.errno not in [errno.ENOENT, errno.EROFS]:

                raise

            # Workaround for dulwich crashing on for example its own dulwich/tests/data/repos/simple_merge.git/info/refs.lock

            log.error('Ignoring %s running update-server-info: %s', type(e).__name__, e)

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        return GitWorkdir(self)

    def get_config_value(self, section, name, config_file=None):

        """

        Returns configuration value for a given [``section``] and ``name``.

        :param section: Section we want to retrieve value from

        :param name: Name of configuration we want to retrieve

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        if config_file is None:

            config_file = []

        elif isinstance(config_file, basestring):

            config_file = [config_file]

        def gen_configs():

            for path in config_file + self._config_files:

                try:

                    yield ConfigFile.from_path(path)

                except (IOError, OSError, ValueError):

                    continue

        for config in gen_configs():

            try:

                return config.get(section, name)

            except KeyError:

                continue

        return None

    def get_user_name(self, config_file=None):

        """

        Returns user's name from global configuration file.

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        return self.get_config_value('user', 'name', config_file)

    def get_user_email(self, config_file=None):

        """

        Returns user's email from global configuration file.

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        return self.get_config_value('user', 'email', config_file)

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                    ],

                },

                'e29b67bd158580fc90fc5e9111240b90e6e86064': {

                    'lines_no': 32,

                    'changesets': [

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '5eab1222a7cd4bfcbabc218ca6d04276d4e27378',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '54000345d2e78b03a99d561399e8e548de3f3203',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '78c3f0c23b7ee935ec276acb8b8212444c33c396',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '2a13f185e4525f9d4b59882791a2d397b90d5ddc',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '78c3f0c23b7ee935ec276acb8b8212444c33c396',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '992f38217b979d0b0987d0bae3cc26dac85d9b19',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                        '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',

                    ],

                },

            },

        }

        for fname, revision_dict in files.items():

            for rev, data in revision_dict.items():

                cs = self.repo.get_changeset(rev)

                l1_1 = [x[1] for x in cs.get_file_annotate(fname)]

                l1_2 = [x[2]().raw_id for x in cs.get_file_annotate(fname)]

                assert l1_1 == l1_2

                l1 = l1_1

                l2 = files[fname][rev]['changesets']

                assert l1 == l2, "The lists of revision for %s@rev %s" \

                    "from annotation list should match each other, " \

                    "got \n%s \nvs \n%s " % (fname, rev, l1, l2)

    def test_files_state(self):

        """

        Tests state of FileNodes.

        """

        node = self.repo \

            .get_changeset('e6ea6d16e2f26250124a1f4b4fe37a912f9d86a0') \

            .get_node('vcs/utils/diffs.py')

        assert node.state, NodeState.ADDED

        assert node.added

        assert not node.changed

        assert not node.not_changed

        assert not node.removed

        node = self.repo \

            .get_changeset('33fa3223355104431402a888fa77a4e9956feb3e') \

            .get_node('.hgignore')

        assert node.state, NodeState.CHANGED

        assert not node.added

        assert node.changed

        assert not node.not_changed

        assert not node.removed

        node = self.repo \

            .get_changeset('e29b67bd158580fc90fc5e9111240b90e6e86064') \

            .get_node('setup.py')

        assert node.state, NodeState.NOT_CHANGED

        assert not node.added

        assert not node.changed

        assert node.not_changed

        assert not node.removed

        # If node has REMOVED state then trying to fetch it would raise

        # ChangesetError exception

        chset = self.repo.get_changeset(

            'fa6600f6848800641328adbf7811fd2372c02ab2')

        path = 'vcs/backends/BaseRepository.py'

        with pytest.raises(NodeDoesNotExistError):

            chset.get_node(path)

        # but it would be one of ``removed`` (changeset's attribute)

        assert path in [rf.path for rf in chset.removed]

        chset = self.repo.get_changeset(

            '54386793436c938cff89326944d4c2702340037d')

        changed = ['setup.py', 'tests/test_nodes.py', 'vcs/backends/hg.py',

            'vcs/nodes.py']

        assert set(changed) == set([f.path for f in chset.changed])

    def test_commit_message_is_unicode(self):

        for cs in self.repo:

            assert isinstance(cs.message, unicode)

    def test_changeset_author_is_unicode(self):

        for cs in self.repo:

            assert isinstance(cs.author, unicode)

    def test_repo_files_content_is_unicode(self):

        changeset = self.repo.get_changeset()

        for node in changeset.get_node('/'):

            if node.is_file():

                assert isinstance(node.content, unicode)

    def test_wrong_path(self):

        # There is 'setup.py' in the root dir but not there:

        path = 'foo/bar/setup.py'

        tip = self.repo.get_changeset()

        with pytest.raises(VCSError):

            tip.get_node(path)

    def test_author_email(self):

        assert 'marcin@python-blog.com' == self.repo.get_changeset('c1214f7e79e02fc37156ff215cd71275450cffc3').author_email

        assert 'lukasz.balcerzak@python-center.pl' == self.repo.get_changeset('ff7ca51e58c505fec0dd2491de52c622bb7a806b').author_email

        assert '' == self.repo.get_changeset('8430a588b43b5d6da365400117c89400326e7992').author_email

    def test_author_username(self):

        assert 'Marcin Kuzminski' == self.repo.get_changeset('c1214f7e79e02fc37156ff215cd71275450cffc3').author_name

        assert 'Lukasz Balcerzak' == self.repo.get_changeset('ff7ca51e58c505fec0dd2491de52c622bb7a806b').author_name

        assert 'marcink none@none' == self.repo.get_changeset('8430a588b43b5d6da365400117c89400326e7992').author_name

class TestGitSpecificWithRepo(_BackendTestMixin):

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

                        mode=0o120000), # this is a link

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

                ],

            },

            {

                'message': 'Second',

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

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

                'added': [

                    FileNode('foo2', content='foo2'),

                ],

            },

        ]

    def test_paths_slow_traversing(self):

        cs = self.repo.get_changeset()

        assert cs.get_node('foobar').get_node('static').get_node('js').get_node('admin').get_node('base.js').content == 'base'

    def test_paths_fast_traversing(self):

        cs = self.repo.get_changeset()

        assert cs.get_node('foobar/static/js/admin/base.js').content == 'base'

    def test_workdir_get_branch(self):

        self.repo.run_git_command(['checkout', '-b', 'production'])

        # Regression test: one of following would fail if we don't check

        # .git/HEAD file

        self.repo.run_git_command(['checkout', 'production'])

        assert self.repo.workdir.get_branch() == 'production'

        self.repo.run_git_command(['checkout', 'master'])

        assert self.repo.workdir.get_branch() == 'master'

    def test_get_diff_runs_git_command_with_hashes(self):

        self.repo.get_diff(0, 1)

            ['diff', '-U3', '--full-index', '--binary', '-p', '-M', '--abbrev=40',

    def test_get_diff_runs_git_command_with_str_hashes(self):

        self.repo.get_diff(self.repo.EMPTY_CHANGESET, 1)

            ['show', '-U3', '--full-index', '--binary', '-p', '-M', '--abbrev=40',

    def test_get_diff_runs_git_command_with_path_if_its_given(self):

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

            ['diff', '-U3', '--full-index', '--binary', '-p', '-M', '--abbrev=40',

    def test_get_diff_does_not_sanitize_valid_context(self):

        almost_overflowed_long_int = 2**31-1

        self.repo.get_diff(0, 1, 'foo', context=almost_overflowed_long_int)

            ['diff', '-U' + str(almost_overflowed_long_int), '--full-index', '--binary', '-p', '-M', '--abbrev=40',

    def test_get_diff_sanitizes_overflowing_context(self):

        overflowed_long_int = 2**31

        sanitized_overflowed_long_int = overflowed_long_int-1

        self.repo.get_diff(0, 1, 'foo', context=overflowed_long_int)

            ['diff', '-U' + str(sanitized_overflowed_long_int), '--full-index', '--binary', '-p', '-M', '--abbrev=40',

    def test_get_diff_does_not_sanitize_zero_context(self):

        zero_context = 0

        self.repo.get_diff(0, 1, 'foo', context=zero_context)

            ['diff', '-U' + str(zero_context), '--full-index', '--binary', '-p', '-M', '--abbrev=40',

    def test_get_diff_sanitizes_negative_context(self):

        negative_context = -10

        self.repo.get_diff(0, 1, 'foo', context=negative_context)

            ['diff', '-U0', '--full-index', '--binary', '-p', '-M', '--abbrev=40',

class TestGitRegression(_BackendTestMixin):

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

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

                ],

            },

            {

                'message': 'Second',

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

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

                'added': [

                    FileNode('bot/build/migrations/1.py', content='foo2'),

                    FileNode('bot/build/migrations/2.py', content='foo2'),

                    FileNode('bot/build/static/templates/f.html', content='foo2'),

                    FileNode('bot/build/static/templates/f1.html', content='foo2'),

                    FileNode('bot/build/templates/err.html', content='foo2'),

                    FileNode('bot/build/templates/err2.html', content='foo2'),

                ],

            },

        ]

    def test_similar_paths(self):

        cs = self.repo.get_changeset()

        paths = lambda *n: [x.path for x in n]

        assert paths(*cs.get_nodes('bot')) == ['bot/build', 'bot/templates', 'bot/__init__.py']

        assert paths(*cs.get_nodes('bot/build')) == ['bot/build/migrations', 'bot/build/static', 'bot/build/templates']

        assert paths(*cs.get_nodes('bot/build/static')) == ['bot/build/static/templates']

        # this get_nodes below causes troubles !

        assert paths(*cs.get_nodes('bot/build/static/templates')) == ['bot/build/static/templates/f.html', 'bot/build/static/templates/f1.html']

        assert paths(*cs.get_nodes('bot/build/templates')) == ['bot/build/templates/err.html', 'bot/build/templates/err2.html']

        assert paths(*cs.get_nodes('bot/templates/')) == ['bot/templates/404.html', 'bot/templates/500.html']

class TestGitHooks(object):

    """

    Tests related to hook functionality of Git repositories.

    """

    def setup_method(self):

        # For each run we want a fresh repo.

        self.repo_directory = get_new_dir("githookrepo")

        self.repo = GitRepository(self.repo_directory, create=True)

        # Create a dictionary where keys are hook names, and values are paths to

        # them. Deduplicates code in tests a bit.

        self.hook_directory = self.repo.get_hook_location()

        self.kallithea_hooks = dict((h, os.path.join(self.hook_directory, h)) for h in ("pre-receive", "post-receive"))

    def test_hooks_created_if_missing(self):

        """

        Tests if hooks are installed in repository if they are missing.

        """

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

            if os.path.exists(hook_path):

                os.remove(hook_path)

        ScmModel().install_git_hooks(repo=self.repo)

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

            assert os.path.exists(hook_path)

    def test_kallithea_hooks_updated(self):

        """

        Tests if hooks are updated if they are Kallithea hooks already.

        """

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

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

                f.write("KALLITHEA_HOOK_VER=0.0.0\nJUST_BOGUS")

        ScmModel().install_git_hooks(repo=self.repo)

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

            with open(hook_path) as f:

                assert "JUST_BOGUS" not in f.read()

    def test_custom_hooks_untouched(self):

        """

        Tests if hooks are left untouched if they are not Kallithea 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)

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

            with open(hook_path) as f:

                assert "CUSTOM_HOOK" in f.read()

    def test_custom_hooks_forced_update(self):

        """

        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:

                assert "KALLITHEA_HOOK_VER" in f.read()