if rev1 == self.EMPTY_CHANGESET:

            rev2 = self.get_changeset(rev2).raw_id

            cmd = ' '.join(['show'] + flags + [rev2])

        else:

            rev1 = self.get_changeset(rev1).raw_id

            rev2 = self.get_changeset(rev2).raw_id

            cmd = ' '.join(['diff'] + flags + [rev1, rev2])

        if path:

            cmd += ' -- "%s"' % path

        stdout, stderr = self.run_git_command(cmd)

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

        # starts)

        if rev1 == self.EMPTY_CHANGESET:

            lines = stdout.splitlines()

            x = 0

            for line in lines:

                if line.startswith('diff'):

                    break

                x += 1

            # Append new line just like 'diff' command do

            stdout = '\n'.join(lines[x:]) + '\n'

        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 = ' '.join(cmd)

        # 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", quote(url)]

        cmd = ' '.join(cmd)

        # 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 %s' % quote(url))

        refs = []

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

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

            refs.append(ref)

        refs = ' '.join(('+%s:%s' % (r, r) for r in refs))

        cmd = '''fetch %s -- %s''' % (quote(url), refs)

        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

        update_server_info(self._repo)

    @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

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

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

        with self.assertRaises(urllib2.URLError):

        with self.assertRaises(RepositoryError):

            # Should fail on direct clone call, which as of this writing does not happen outside of class

            clone_fail_repo = GitRepository(get_new_dir('injection-repo'), create=True)

        # Repo should have been created

        self.assertFalse(successfully_cloned._repo.bare)

    def test_repo_clone(self):

        self.__check_for_existing_repo()

        repo = GitRepository(TEST_GIT_REPO)

        repo_clone = GitRepository(TEST_GIT_REPO_CLONE,

            src_url=TEST_GIT_REPO, create=True, update_after_clone=True)

        self.assertEqual(len(repo.revisions), len(repo_clone.revisions))

        # Checking hashes of changesets should be enough

        for changeset in repo.get_changesets():

            raw_id = changeset.raw_id

            self.assertEqual(raw_id, repo_clone.get_changeset(raw_id).raw_id)

    def test_repo_clone_without_create(self):

        self.assertRaises(RepositoryError, GitRepository,

            TEST_GIT_REPO_CLONE + '_wo_create', src_url=TEST_GIT_REPO)

    def test_repo_clone_with_update(self):

        repo = GitRepository(TEST_GIT_REPO)

        clone_path = TEST_GIT_REPO_CLONE + '_with_update'

        repo_clone = GitRepository(clone_path,

            create=True, src_url=TEST_GIT_REPO, update_after_clone=True)

        self.assertEqual(len(repo.revisions), len(repo_clone.revisions))

        #check if current workdir was updated

        fpath = os.path.join(clone_path, 'MANIFEST.in')

        self.assertEqual(True, os.path.isfile(fpath),

            'Repo was cloned and updated but file %s could not be found'

            % fpath)

    def test_repo_clone_without_update(self):

        repo = GitRepository(TEST_GIT_REPO)

        clone_path = TEST_GIT_REPO_CLONE + '_without_update'

        repo_clone = GitRepository(clone_path,

            create=True, src_url=TEST_GIT_REPO, update_after_clone=False)

        self.assertEqual(len(repo.revisions), len(repo_clone.revisions))

        #check if current workdir was *NOT* updated

        fpath = os.path.join(clone_path, 'MANIFEST.in')

        # Make sure it's not bare repo

        self.assertFalse(repo_clone._repo.bare)

        self.assertEqual(False, os.path.isfile(fpath),

            'Repo was cloned and updated but file %s was found'

            % fpath)

    def test_repo_clone_into_bare_repo(self):

        repo = GitRepository(TEST_GIT_REPO)

        clone_path = TEST_GIT_REPO_CLONE + '_bare.git'

        repo_clone = GitRepository(clone_path, create=True,

            src_url=repo.path, bare=True)