git: replaced some raw subprocess commands with dedicated GIT vcsserver commands.

rhodecode/lib/vcs/backends/git/commit.py

@@ -1,507 +1,474 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 GIT commit module
 """
 
 import re
 import stat
 from itertools import chain
 from StringIO import StringIO
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.lib.datelib import utcdate_fromtimestamp
 from rhodecode.lib.utils import safe_unicode, safe_str
 from rhodecode.lib.utils2 import safe_int
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.backends import base
 from rhodecode.lib.vcs.exceptions import CommitError, NodeDoesNotExistError
 from rhodecode.lib.vcs.nodes import (
     FileNode, DirNode, NodeKind, RootNode, SubModuleNode,
     ChangedFileNodesGenerator, AddedFileNodesGenerator,
     RemovedFileNodesGenerator, LargeFileNode)
 from rhodecode.lib.vcs.compat import configparser
 
 
 class GitCommit(base.BaseCommit):
     """
     Represents state of the repository at single commit id.
     """
 
     _filter_pre_load = [
         # done through a more complex tree walk on parents
         "affected_files",
         # done through subprocess not remote call
         "children",
         # done through a more complex tree walk on parents
         "status",
         # mercurial specific property not supported here
         "_file_paths",
         # mercurial specific property not supported here
         'obsolete',
         # mercurial specific property not supported here
         'phase',
         # mercurial specific property not supported here
         'hidden'
     ]
 
     def __init__(self, repository, raw_id, idx, pre_load=None):
         self.repository = repository
         self._remote = repository._remote
         # TODO: johbo: Tweak of raw_id should not be necessary
         self.raw_id = safe_str(raw_id)
         self.idx = idx
 
         self._set_bulk_properties(pre_load)
 
         # caches
         self._stat_modes = {}  # stat info for paths
         self._paths = {}  # path processed with parse_tree
         self.nodes = {}
         self._submodules = None
 
     def _set_bulk_properties(self, pre_load):
 
         if not pre_load:
             return
         pre_load = [entry for entry in pre_load
                     if entry not in self._filter_pre_load]
         if not pre_load:
             return
 
         result = self._remote.bulk_request(self.raw_id, pre_load)
         for attr, value in result.items():
             if attr in ["author", "message"]:
                 if value:
                     value = safe_unicode(value)
             elif attr == "date":
                 value = utcdate_fromtimestamp(*value)
             elif attr == "parents":
                 value = self._make_commits(value)
             elif attr == "branch":
                 value = value[0] if value else None
             self.__dict__[attr] = value
 
     @LazyProperty
     def _commit(self):
         return self._remote[self.raw_id]
 
     @LazyProperty
     def _tree_id(self):
         return self._remote[self._commit['tree']]['id']
 
     @LazyProperty
     def id(self):
         return self.raw_id
 
     @LazyProperty
     def short_id(self):
         return self.raw_id[:12]
 
     @LazyProperty
     def message(self):
         return safe_unicode(self._remote.message(self.id))
 
     @LazyProperty
     def committer(self):
         return safe_unicode(self._remote.author(self.id))
 
     @LazyProperty
     def author(self):
         return safe_unicode(self._remote.author(self.id))
 
     @LazyProperty
     def date(self):
         unix_ts, tz = self._remote.date(self.raw_id)
         return utcdate_fromtimestamp(unix_ts, tz)
 
     @LazyProperty
     def status(self):
         """
         Returns modified, added, removed, deleted files for current commit
         """
         return self.changed, self.added, self.removed
 
     @LazyProperty
     def tags(self):
         tags = [safe_unicode(name) for name,
                 commit_id in self.repository.tags.iteritems()
                 if commit_id == self.raw_id]
         return tags
 
     @LazyProperty
     def commit_branches(self):
         branches = []
         for name, commit_id in self.repository.branches.iteritems():
             if commit_id == self.raw_id:
                 branches.append(name)
         return branches
 
     @LazyProperty
     def branch(self):
         branches = self._remote.branch(self.raw_id)
 
         if branches:
             # actually commit can have multiple branches in git
             return safe_unicode(branches[0])
 
     def _get_tree_id_for_path(self, path):
         path = safe_str(path)
         if path in self._paths:
             return self._paths[path]
 
         tree_id = self._tree_id
 
         path = path.strip('/')
         if path == '':
             data = [tree_id, "tree"]
             self._paths[''] = data
             return data
 
         tree_id, tree_type, tree_mode = \
             self._remote.tree_and_type_for_path(self.raw_id, path)
         if tree_id is None:
             raise self.no_node_at_path(path)
 
         self._paths[path] = [tree_id, tree_type]
         self._stat_modes[path] = tree_mode
 
         if path not in self._paths:
             raise self.no_node_at_path(path)
 
         return self._paths[path]
 
     def _get_kind(self, path):
         tree_id, type_ = self._get_tree_id_for_path(path)
         if type_ == 'blob':
             return NodeKind.FILE
         elif type_ == 'tree':
             return NodeKind.DIR
         elif type_ == 'link':
             return NodeKind.SUBMODULE
         return None
 
     def _get_filectx(self, path):
         path = self._fix_path(path)
         if self._get_kind(path) != NodeKind.FILE:
             raise CommitError(
                 "File does not exist for commit %s at  '%s'" % (self.raw_id, path))
         return path
 
     def _get_file_nodes(self):
         return chain(*(t[2] for t in self.walk()))
 
     @LazyProperty
     def parents(self):
         """
         Returns list of parent commits.
         """
         parent_ids = self._remote.parents(self.id)
         return self._make_commits(parent_ids)
 
     @LazyProperty
     def children(self):
         """
         Returns list of child commits.
         """
-        rev_filter = settings.GIT_REV_FILTER
-        output, __ = self.repository.run_git_command(
-            ['rev-list', '--children'] + rev_filter)
 
-        child_ids = []
-        pat = re.compile(r'^%s' % self.raw_id)
-        for l in output.splitlines():
-            if pat.match(l):
-                found_ids = l.split(' ')[1:]
-                child_ids.extend(found_ids)
-        return self._make_commits(child_ids)
+        children = self._remote.children(self.raw_id)
+        return self._make_commits(children)
 
     def _make_commits(self, commit_ids):
         def commit_maker(_commit_id):
             return self.repository.get_commit(commit_id=commit_id)
 
         return [commit_maker(commit_id) for commit_id in commit_ids]
 
     def get_file_mode(self, path):
         """
         Returns stat mode of the file at the given `path`.
         """
         path = safe_str(path)
         # ensure path is traversed
         self._get_tree_id_for_path(path)
         return self._stat_modes[path]
 
     def is_link(self, path):
         return stat.S_ISLNK(self.get_file_mode(path))
 
     def get_file_content(self, path):
         """
         Returns content of the file at given `path`.
         """
         tree_id, _ = self._get_tree_id_for_path(path)
         return self._remote.blob_as_pretty_string(tree_id)
 
     def get_file_size(self, path):
         """
         Returns size of the file at given `path`.
         """
         tree_id, _ = self._get_tree_id_for_path(path)
         return self._remote.blob_raw_length(tree_id)
 
     def get_path_history(self, path, limit=None, pre_load=None):
         """
         Returns history of file as reversed list of `GitCommit` objects for
         which file at given `path` has been modified.
-
-        TODO: This function now uses an underlying 'git' command which works
-        quickly but ideally we should replace with an algorithm.
         """
-        self._get_filectx(path)
-        f_path = safe_str(path)
 
-        # optimize for n==1, rev-list is much faster for that use-case
-        if limit == 1:
-            cmd = ['rev-list', '-1', self.raw_id, '--', f_path]
-        else:
-            cmd = ['log']
-            if limit:
-                cmd.extend(['-n', str(safe_int(limit, 0))])
-            cmd.extend(['--pretty=format: %H', '-s', self.raw_id, '--', f_path])
-
-        output, __ = self.repository.run_git_command(cmd)
-        commit_ids = re.findall(r'[0-9a-fA-F]{40}', output)
-
+        path = self._get_filectx(path)
+        hist = self._remote.node_history(self.raw_id, path, limit)
         return [
             self.repository.get_commit(commit_id=commit_id, pre_load=pre_load)
-            for commit_id in commit_ids]
+            for commit_id in hist]
 
     def get_file_annotate(self, path, pre_load=None):
         """
         Returns a generator of four element tuples with
             lineno, commit_id, commit lazy loader and line
+        """
 
-        TODO: This function now uses os underlying 'git' command which is
-        generally not good. Should be replaced with algorithm iterating
-        commits.
-        """
-        cmd = ['blame', '-l', '--root', '-r', self.raw_id, '--', path]
-        # -l     ==> outputs long shas (and we need all 40 characters)
-        # --root ==> doesn't put '^' character for bounderies
-        # -r commit_id ==> blames for the given commit
-        output, __ = self.repository.run_git_command(cmd)
+        result = self._remote.node_annotate(self.raw_id, path)
 
-        for i, blame_line in enumerate(output.split('\n')[:-1]):
-            line_no = i + 1
-            commit_id, line = re.split(r' ', blame_line, 1)
+        for ln_no, commit_id, content in result:
             yield (
-                line_no, commit_id,
-                lambda: self.repository.get_commit(commit_id=commit_id,
-                                                   pre_load=pre_load),
-                line)
+                ln_no, commit_id,
+                lambda: self.repository.get_commit(commit_id=commit_id, pre_load=pre_load),
+                content)
 
     def get_nodes(self, path):
 
         if self._get_kind(path) != NodeKind.DIR:
             raise CommitError(
                 "Directory does not exist for commit %s at '%s'" % (self.raw_id, path))
         path = self._fix_path(path)
 
         tree_id, _ = self._get_tree_id_for_path(path)
 
         dirnodes = []
         filenodes = []
 
         # extracted tree ID gives us our files...
         for name, stat_, id_, type_ in self._remote.tree_items(tree_id):
             if type_ == 'link':
                 url = self._get_submodule_url('/'.join((path, name)))
                 dirnodes.append(SubModuleNode(
                     name, url=url, commit=id_, alias=self.repository.alias))
                 continue
 
             if path != '':
                 obj_path = '/'.join((path, name))
             else:
                 obj_path = name
             if obj_path not in self._stat_modes:
                 self._stat_modes[obj_path] = stat_
 
             if type_ == 'tree':
                 dirnodes.append(DirNode(obj_path, commit=self))
             elif type_ == 'blob':
                 filenodes.append(FileNode(obj_path, commit=self, mode=stat_))
             else:
                 raise CommitError(
                     "Requested object should be Tree or Blob, is %s", type_)
 
         nodes = dirnodes + filenodes
         for node in nodes:
             if node.path not in self.nodes:
                 self.nodes[node.path] = node
         nodes.sort()
         return nodes
 
     def get_node(self, path, pre_load=None):
         if isinstance(path, unicode):
             path = path.encode('utf-8')
         path = self._fix_path(path)
         if path not in self.nodes:
             try:
                 tree_id, type_ = self._get_tree_id_for_path(path)
             except CommitError:
                 raise NodeDoesNotExistError(
                     "Cannot find one of parents' directories for a given "
                     "path: %s" % path)
 
             if type_ == 'link':
                 url = self._get_submodule_url(path)
                 node = SubModuleNode(path, url=url, commit=tree_id,
                                      alias=self.repository.alias)
             elif type_ == 'tree':
                 if path == '':
                     node = RootNode(commit=self)
                 else:
                     node = DirNode(path, commit=self)
             elif type_ == 'blob':
                 node = FileNode(path, commit=self, pre_load=pre_load)
                 self._stat_modes[path] = node.mode
             else:
                 raise self.no_node_at_path(path)
 
             # cache node
             self.nodes[path] = node
 
         return self.nodes[path]
 
     def get_largefile_node(self, path):
         tree_id, _ = self._get_tree_id_for_path(path)
         pointer_spec = self._remote.is_large_file(tree_id)
 
         if pointer_spec:
             # content of that file regular FileNode is the hash of largefile
             file_id = pointer_spec.get('oid_hash')
             if self._remote.in_largefiles_store(file_id):
                 lf_path = self._remote.store_path(file_id)
                 return LargeFileNode(lf_path, commit=self, org_path=path)
 
     @LazyProperty
     def affected_files(self):
         """
         Gets a fast accessible file changes for given commit
         """
         added, modified, deleted = self._changes_cache
         return list(added.union(modified).union(deleted))
 
     @LazyProperty
     def _changes_cache(self):
         added = set()
         modified = set()
         deleted = set()
         _r = self._remote
 
         parents = self.parents
         if not self.parents:
             parents = [base.EmptyCommit()]
         for parent in parents:
             if isinstance(parent, base.EmptyCommit):
                 oid = None
             else:
                 oid = parent.raw_id
             changes = _r.tree_changes(oid, self.raw_id)
             for (oldpath, newpath), (_, _), (_, _) in changes:
                 if newpath and oldpath:
                     modified.add(newpath)
                 elif newpath and not oldpath:
                     added.add(newpath)
                 elif not newpath and oldpath:
                     deleted.add(oldpath)
         return added, modified, deleted
 
     def _get_paths_for_status(self, status):
         """
         Returns sorted list of paths for given ``status``.
 
         :param status: one of: *added*, *modified* or *deleted*
         """
         added, modified, deleted = self._changes_cache
         return sorted({
             'added': list(added),
             'modified': list(modified),
             'deleted': list(deleted)}[status]
         )
 
     @LazyProperty
     def added(self):
         """
         Returns list of added ``FileNode`` objects.
         """
         if not self.parents:
             return list(self._get_file_nodes())
         return AddedFileNodesGenerator(
             [n for n in self._get_paths_for_status('added')], self)
 
     @LazyProperty
     def changed(self):
         """
         Returns list of modified ``FileNode`` objects.
         """
         if not self.parents:
             return []
         return ChangedFileNodesGenerator(
             [n for n in self._get_paths_for_status('modified')], self)
 
     @LazyProperty
     def removed(self):
         """
         Returns list of removed ``FileNode`` objects.
         """
         if not self.parents:
             return []
         return RemovedFileNodesGenerator(
             [n for n in self._get_paths_for_status('deleted')], self)
 
     def _get_submodule_url(self, submodule_path):
         git_modules_path = '.gitmodules'
 
         if self._submodules is None:
             self._submodules = {}
 
             try:
                 submodules_node = self.get_node(git_modules_path)
             except NodeDoesNotExistError:
                 return None
 
             content = submodules_node.content
 
             # ConfigParser fails if there are whitespaces
             content = '\n'.join(l.strip() for l in content.split('\n'))
 
             parser = configparser.ConfigParser()
             parser.readfp(StringIO(content))
 
             for section in parser.sections():
                 path = parser.get(section, 'path')
                 url = parser.get(section, 'url')
                 if path and url:
                     self._submodules[path.strip('/')] = url
 
         return self._submodules.get(submodule_path.strip('/'))

rhodecode/lib/vcs/backends/git/repository.py

@@ -1,1021 +1,1004 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 GIT repository module
 """
 
 import logging
 import os
 import re
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.datelib import (
     utcdate_fromtimestamp, makedate, date_astimestamp)
 from rhodecode.lib.utils import safe_unicode, safe_str
 from rhodecode.lib.utils2 import CachedProperty
 from rhodecode.lib.vcs import connection, path as vcspath
 from rhodecode.lib.vcs.backends.base import (
     BaseRepository, CollectionGenerator, Config, MergeResponse,
     MergeFailureReason, Reference)
 from rhodecode.lib.vcs.backends.git.commit import GitCommit
 from rhodecode.lib.vcs.backends.git.diff import GitDiff
 from rhodecode.lib.vcs.backends.git.inmemory import GitInMemoryCommit
 from rhodecode.lib.vcs.exceptions import (
     CommitDoesNotExistError, EmptyRepositoryError,
     RepositoryError, TagAlreadyExistError, TagDoesNotExistError, VCSError)
 
 
 SHA_PATTERN = re.compile(r'^[[0-9a-fA-F]{12}|[0-9a-fA-F]{40}]$')
 
 log = logging.getLogger(__name__)
 
 
 class GitRepository(BaseRepository):
     """
     Git repository backend.
     """
     DEFAULT_BRANCH_NAME = 'master'
 
     contact = BaseRepository.DEFAULT_CONTACT
 
     def __init__(self, repo_path, config=None, create=False, src_url=None,
                  do_workspace_checkout=False, with_wire=None, bare=False):
 
         self.path = safe_str(os.path.abspath(repo_path))
         self.config = config if config else self.get_default_config()
         self.with_wire = with_wire or {"cache": False}  # default should not use cache
 
         self._init_repo(create, src_url, do_workspace_checkout, bare)
 
         # caches
         self._commit_ids = {}
 
     @LazyProperty
     def _remote(self):
         repo_id = self.path
         return connection.Git(self.path, repo_id, self.config, with_wire=self.with_wire)
 
     @LazyProperty
     def bare(self):
         return self._remote.bare()
 
     @LazyProperty
     def head(self):
         return self._remote.head()
 
     @CachedProperty
     def commit_ids(self):
         """
         Returns list of commit ids, in ascending order.  Being lazy
         attribute allows external tools to inject commit ids from cache.
         """
         commit_ids = self._get_all_commit_ids()
         self._rebuild_cache(commit_ids)
         return commit_ids
 
     def _rebuild_cache(self, commit_ids):
         self._commit_ids = dict((commit_id, index)
                                 for index, commit_id in enumerate(commit_ids))
 
     def run_git_command(self, cmd, **opts):
         """
         Runs given ``cmd`` as git command and returns tuple
         (stdout, stderr).
 
         :param cmd: git command to be executed
         :param opts: env options to pass into Subprocess command
         """
         if not isinstance(cmd, list):
             raise ValueError('cmd must be a list, got %s instead' % type(cmd))
 
         skip_stderr_log = opts.pop('skip_stderr_log', False)
         out, err = self._remote.run_git_command(cmd, **opts)
         if err and not skip_stderr_log:
             log.debug('Stderr output of git command "%s":\n%s', cmd, err)
         return out, err
 
     @staticmethod
     def check_url(url, config):
         """
         Function will check given url and try to verify if it's a valid
         link. Sometimes it may happened that git will issue basic
         auth request that can cause whole API to hang when used from python
         or other external calls.
 
         On failures it'll raise urllib2.HTTPError, exception is also thrown
         when the return code is non 200
         """
         # check first if it's not an url
         if os.path.isdir(url) or url.startswith('file:'):
             return True
 
         if '+' in url.split('://', 1)[0]:
             url = url.split('+', 1)[1]
 
         # Request the _remote to verify the url
         return connection.Git.check_url(url, config.serialize())
 
     @staticmethod
     def is_valid_repository(path):
         if os.path.isdir(os.path.join(path, '.git')):
             return True
         # check case of bare repository
         try:
             GitRepository(path)
             return True
         except VCSError:
             pass
         return False
 
     def _init_repo(self, create, src_url=None, do_workspace_checkout=False,
                    bare=False):
         if create and os.path.exists(self.path):
             raise RepositoryError(
                 "Cannot create repository at %s, location already exist"
                 % self.path)
 
         if bare and do_workspace_checkout:
             raise RepositoryError("Cannot update a bare repository")
         try:
 
             if src_url:
                 # check URL before any actions
                 GitRepository.check_url(src_url, self.config)
 
             if create:
                 os.makedirs(self.path, mode=0o755)
 
                 if bare:
                     self._remote.init_bare()
                 else:
                     self._remote.init()
 
                 if src_url and bare:
                     # bare repository only allows a fetch and checkout is not allowed
                     self.fetch(src_url, commit_ids=None)
                 elif src_url:
                     self.pull(src_url, commit_ids=None,
                               update_after=do_workspace_checkout)
 
             else:
                 if not self._remote.assert_correct_path():
                     raise RepositoryError(
                         'Path "%s" does not contain a Git repository' %
                         (self.path,))
 
         # TODO: johbo: check if we have to translate the OSError here
         except OSError as err:
             raise RepositoryError(err)
 
     def _get_all_commit_ids(self):
         return self._remote.get_all_commit_ids()
 
     def _get_commit_ids(self, filters=None):
         # we must check if this repo is not empty, since later command
         # fails if it is. And it's cheaper to ask than throw the subprocess
         # errors
 
         head = self._remote.head(show_exc=False)
 
         if not head:
             return []
 
         rev_filter = ['--branches', '--tags']
         extra_filter = []
 
         if filters:
             if filters.get('since'):
                 extra_filter.append('--since=%s' % (filters['since']))
             if filters.get('until'):
                 extra_filter.append('--until=%s' % (filters['until']))
             if filters.get('branch_name'):
                 rev_filter = []
                 extra_filter.append(filters['branch_name'])
         rev_filter.extend(extra_filter)
 
             # if filters.get('start') or filters.get('end'):
             #     # skip is offset, max-count is limit
             #     if filters.get('start'):
             #         extra_filter += ' --skip=%s' % filters['start']
             #     if filters.get('end'):
             #         extra_filter += ' --max-count=%s' % (filters['end'] - (filters['start'] or 0))
 
         cmd = ['rev-list', '--reverse', '--date-order'] + rev_filter
         try:
             output, __ = self.run_git_command(cmd)
         except RepositoryError:
             # Can be raised for empty repositories
             return []
         return output.splitlines()
 
     def _lookup_commit(self, commit_id_or_idx, translate_tag=True):
         def is_null(value):
             return len(value) == commit_id_or_idx.count('0')
 
         if commit_id_or_idx in (None, '', 'tip', 'HEAD', 'head', -1):
             return self.commit_ids[-1]
         commit_missing_err = "Commit {} does not exist for `{}`".format(
             *map(safe_str, [commit_id_or_idx, self.name]))
 
         is_bstr = isinstance(commit_id_or_idx, (str, unicode))
         if ((is_bstr and commit_id_or_idx.isdigit() and len(commit_id_or_idx) < 12)
             or isinstance(commit_id_or_idx, int) or is_null(commit_id_or_idx)):
             try:
                 commit_id_or_idx = self.commit_ids[int(commit_id_or_idx)]
             except Exception:
                 raise CommitDoesNotExistError(commit_missing_err)
 
         elif is_bstr:
             # Need to call remote to translate id for tagging scenario
             try:
                 remote_data = self._remote.get_object(commit_id_or_idx)
                 commit_id_or_idx = remote_data["commit_id"]
             except (CommitDoesNotExistError,):
                 raise CommitDoesNotExistError(commit_missing_err)
 
         # Ensure we return full id
         if not SHA_PATTERN.match(str(commit_id_or_idx)):
             raise CommitDoesNotExistError(
                 "Given commit id %s not recognized" % commit_id_or_idx)
         return commit_id_or_idx
 
     def get_hook_location(self):
         """
         returns absolute path to location where hooks are stored
         """
         loc = os.path.join(self.path, 'hooks')
         if not self.bare:
             loc = os.path.join(self.path, '.git', 'hooks')
         return loc
 
     @LazyProperty
     def last_change(self):
         """
         Returns last change made on this repository as
         `datetime.datetime` object.
         """
         try:
             return self.get_commit().date
         except RepositoryError:
             tzoffset = makedate()[1]
             return utcdate_fromtimestamp(self._get_fs_mtime(), tzoffset)
 
     def _get_fs_mtime(self):
         idx_loc = '' if self.bare else '.git'
         # fallback to filesystem
         in_path = os.path.join(self.path, idx_loc, "index")
         he_path = os.path.join(self.path, idx_loc, "HEAD")
         if os.path.exists(in_path):
             return os.stat(in_path).st_mtime
         else:
             return os.stat(he_path).st_mtime
 
     @LazyProperty
     def description(self):
         description = self._remote.get_description()
         return safe_unicode(description or self.DEFAULT_DESCRIPTION)
 
     def _get_refs_entries(self, prefix='', reverse=False, strip_prefix=True):
         if self.is_empty():
             return OrderedDict()
 
         result = []
         for ref, sha in self._refs.iteritems():
             if ref.startswith(prefix):
                 ref_name = ref
                 if strip_prefix:
                     ref_name = ref[len(prefix):]
                 result.append((safe_unicode(ref_name), sha))
 
         def get_name(entry):
             return entry[0]
 
         return OrderedDict(sorted(result, key=get_name, reverse=reverse))
 
     def _get_branches(self):
         return self._get_refs_entries(prefix='refs/heads/', strip_prefix=True)
 
     @CachedProperty
     def branches(self):
         return self._get_branches()
 
     @CachedProperty
     def branches_closed(self):
         return {}
 
     @CachedProperty
     def bookmarks(self):
         return {}
 
     @CachedProperty
     def branches_all(self):
         all_branches = {}
         all_branches.update(self.branches)
         all_branches.update(self.branches_closed)
         return all_branches
 
     @CachedProperty
     def tags(self):
         return self._get_tags()
 
     def _get_tags(self):
         return self._get_refs_entries(prefix='refs/tags/', strip_prefix=True, reverse=True)
 
     def tag(self, name, user, commit_id=None, message=None, date=None,
             **kwargs):
         # TODO: fix this method to apply annotated tags correct with message
         """
         Creates and returns a tag for the given ``commit_id``.
 
         :param name: name for new tag
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param commit_id: commit id for which new tag would be created
         :param message: message of the tag's commit
         :param date: date of tag's commit
 
         :raises TagAlreadyExistError: if tag with same name already exists
         """
         if name in self.tags:
             raise TagAlreadyExistError("Tag %s already exists" % name)
         commit = self.get_commit(commit_id=commit_id)
         message = message or "Added tag %s for commit %s" % (name, commit.raw_id)
 
         self._remote.set_refs('refs/tags/%s' % name, commit.raw_id)
 
         self._invalidate_prop_cache('tags')
         self._invalidate_prop_cache('_refs')
 
         return commit
 
     def remove_tag(self, name, user, message=None, date=None):
         """
         Removes tag with the given ``name``.
 
         :param name: name of the tag to be removed
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param message: message of the tag's removal commit
         :param date: date of tag's removal commit
 
         :raises TagDoesNotExistError: if tag with given name does not exists
         """
         if name not in self.tags:
             raise TagDoesNotExistError("Tag %s does not exist" % name)
 
         self._remote.tag_remove(name)
         self._invalidate_prop_cache('tags')
         self._invalidate_prop_cache('_refs')
 
     def _get_refs(self):
         return self._remote.get_refs()
 
     @CachedProperty
     def _refs(self):
         return self._get_refs()
 
     @property
     def _ref_tree(self):
         node = tree = {}
         for ref, sha in self._refs.iteritems():
             path = ref.split('/')
             for bit in path[:-1]:
                 node = node.setdefault(bit, {})
             node[path[-1]] = sha
             node = tree
         return tree
 
     def get_remote_ref(self, ref_name):
         ref_key = 'refs/remotes/origin/{}'.format(safe_str(ref_name))
         try:
             return self._refs[ref_key]
         except Exception:
             return
 
     def get_commit(self, commit_id=None, commit_idx=None, pre_load=None, translate_tag=True):
         """
         Returns `GitCommit` object representing commit from git repository
         at the given `commit_id` or head (most recent commit) if None given.
         """
         if self.is_empty():
             raise EmptyRepositoryError("There are no commits yet")
 
         if commit_id is not None:
             self._validate_commit_id(commit_id)
             try:
                 # we have cached idx, use it without contacting the remote
                 idx = self._commit_ids[commit_id]
                 return GitCommit(self, commit_id, idx, pre_load=pre_load)
             except KeyError:
                 pass
 
         elif commit_idx is not None:
             self._validate_commit_idx(commit_idx)
             try:
                 _commit_id = self.commit_ids[commit_idx]
                 if commit_idx < 0:
                     commit_idx = self.commit_ids.index(_commit_id)
                 return GitCommit(self, _commit_id, commit_idx, pre_load=pre_load)
             except IndexError:
                 commit_id = commit_idx
         else:
             commit_id = "tip"
 
         if translate_tag:
             commit_id = self._lookup_commit(commit_id)
 
         try:
             idx = self._commit_ids[commit_id]
         except KeyError:
             idx = -1
 
         return GitCommit(self, commit_id, idx, pre_load=pre_load)
 
     def get_commits(
             self, start_id=None, end_id=None, start_date=None, end_date=None,
             branch_name=None, show_hidden=False, pre_load=None, translate_tags=True):
         """
         Returns generator of `GitCommit` objects from start to end (both
         are inclusive), in ascending date order.
 
         :param start_id: None, str(commit_id)
         :param end_id: None, str(commit_id)
         :param start_date: if specified, commits with commit date less than
           ``start_date`` would be filtered out from returned set
         :param end_date: if specified, commits with commit date greater than
           ``end_date`` would be filtered out from returned set
         :param branch_name: if specified, commits not reachable from given
           branch would be filtered out from returned set
         :param show_hidden: Show hidden commits such as obsolete or hidden from
             Mercurial evolve
         :raise BranchDoesNotExistError: If given `branch_name` does not
             exist.
         :raise CommitDoesNotExistError: If commits for given `start` or
           `end` could not be found.
 
         """
         if self.is_empty():
             raise EmptyRepositoryError("There are no commits yet")
 
         self._validate_branch_name(branch_name)
 
         if start_id is not None:
             self._validate_commit_id(start_id)
         if end_id is not None:
             self._validate_commit_id(end_id)
 
         start_raw_id = self._lookup_commit(start_id)
         start_pos = self._commit_ids[start_raw_id] if start_id else None
         end_raw_id = self._lookup_commit(end_id)
         end_pos = max(0, self._commit_ids[end_raw_id]) if end_id else None
 
         if None not in [start_id, end_id] and start_pos > end_pos:
             raise RepositoryError(
                 "Start commit '%s' cannot be after end commit '%s'" %
                 (start_id, end_id))
 
         if end_pos is not None:
             end_pos += 1
 
         filter_ = []
         if branch_name:
             filter_.append({'branch_name': branch_name})
         if start_date and not end_date:
             filter_.append({'since': start_date})
         if end_date and not start_date:
             filter_.append({'until': end_date})
         if start_date and end_date:
             filter_.append({'since': start_date})
             filter_.append({'until': end_date})
 
         # if start_pos or end_pos:
         #     filter_.append({'start': start_pos})
         #     filter_.append({'end': end_pos})
 
         if filter_:
             revfilters = {
                 'branch_name': branch_name,
                 'since': start_date.strftime('%m/%d/%y %H:%M:%S') if start_date else None,
                 'until': end_date.strftime('%m/%d/%y %H:%M:%S') if end_date else None,
                 'start': start_pos,
                 'end': end_pos,
             }
             commit_ids = self._get_commit_ids(filters=revfilters)
 
         else:
             commit_ids = self.commit_ids
 
         if start_pos or end_pos:
             commit_ids = commit_ids[start_pos: end_pos]
 
         return CollectionGenerator(self, commit_ids, pre_load=pre_load,
                                    translate_tag=translate_tags)
 
     def get_diff(
             self, commit1, commit2, path='', ignore_whitespace=False,
             context=3, path1=None):
         """
         Returns (git like) *diff*, as plain text. Shows changes introduced by
         ``commit2`` since ``commit1``.
 
         :param commit1: Entry point from which diff is shown. Can be
           ``self.EMPTY_COMMIT`` - in this case, patch showing all
           the changes since empty state of the repository until ``commit2``
         :param commit2: Until which commits 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``.
         """
         self._validate_diff_commits(commit1, commit2)
         if path1 is not None and path1 != path:
             raise ValueError("Diff of two different paths not supported.")
 
-        flags = [
-            '-U%s' % context, '--full-index', '--binary', '-p',
-            '-M', '--abbrev=40']
-        if ignore_whitespace:
-            flags.append('-w')
-
-        if commit1 == self.EMPTY_COMMIT:
-            cmd = ['show'] + flags + [commit2.raw_id]
+        if path:
+            file_filter = path
         else:
-            cmd = ['diff'] + flags + [commit1.raw_id, commit2.raw_id]
-
-        if path:
-            cmd.extend(['--', path])
+            file_filter = None
 
-        stdout, __ = self.run_git_command(cmd)
-        # If we used 'show' command, strip first few lines (until actual diff
-        # starts)
-        if commit1 == self.EMPTY_COMMIT:
-            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 GitDiff(stdout)
+        diff = self._remote.diff(
+            commit1.raw_id, commit2.raw_id, file_filter=file_filter,
+            opt_ignorews=ignore_whitespace,
+            context=context)
+        return GitDiff(diff)
 
     def strip(self, commit_id, branch_name):
         commit = self.get_commit(commit_id=commit_id)
         if commit.merge:
             raise Exception('Cannot reset to merge commit')
 
         # parent is going to be the new head now
         commit = commit.parents[0]
         self._remote.set_refs('refs/heads/%s' % branch_name, commit.raw_id)
 
         # clear cached properties
         self._invalidate_prop_cache('commit_ids')
         self._invalidate_prop_cache('_refs')
         self._invalidate_prop_cache('branches')
 
         return len(self.commit_ids)
 
     def get_common_ancestor(self, commit_id1, commit_id2, repo2):
         if commit_id1 == commit_id2:
             return commit_id1
 
         if self != repo2:
             commits = self._remote.get_missing_revs(
                 commit_id1, commit_id2, repo2.path)
             if commits:
                 commit = repo2.get_commit(commits[-1])
                 if commit.parents:
                     ancestor_id = commit.parents[0].raw_id
                 else:
                     ancestor_id = None
             else:
                 # no commits from other repo, ancestor_id is the commit_id2
                 ancestor_id = commit_id2
         else:
             output, __ = self.run_git_command(
                 ['merge-base', commit_id1, commit_id2])
             ancestor_id = re.findall(r'[0-9a-fA-F]{40}', output)[0]
 
         return ancestor_id
 
     def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
         repo1 = self
         ancestor_id = None
 
         if commit_id1 == commit_id2:
             commits = []
         elif repo1 != repo2:
             missing_ids = self._remote.get_missing_revs(commit_id1, commit_id2,
                                                         repo2.path)
             commits = [
                 repo2.get_commit(commit_id=commit_id, pre_load=pre_load)
                 for commit_id in reversed(missing_ids)]
         else:
             output, __ = repo1.run_git_command(
                 ['log', '--reverse', '--pretty=format: %H', '-s',
                  '%s..%s' % (commit_id1, commit_id2)])
             commits = [
                 repo1.get_commit(commit_id=commit_id, pre_load=pre_load)
                 for commit_id in re.findall(r'[0-9a-fA-F]{40}', output)]
 
         return commits
 
     @LazyProperty
     def in_memory_commit(self):
         """
         Returns ``GitInMemoryCommit`` object for this repository.
         """
         return GitInMemoryCommit(self)
 
     def pull(self, url, commit_ids=None, update_after=False):
         """
         Pull changes from external location. Pull is different in GIT
         that fetch since it's doing a checkout
 
         :param commit_ids: Optional. Can be set to a list of commit ids
            which shall be pulled from the other repository.
         """
         refs = None
         if commit_ids is not None:
             remote_refs = self._remote.get_remote_refs(url)
             refs = [ref for ref in remote_refs if remote_refs[ref] in commit_ids]
         self._remote.pull(url, refs=refs, update_after=update_after)
         self._remote.invalidate_vcs_cache()
 
     def fetch(self, url, commit_ids=None):
         """
         Fetch all git objects from external location.
         """
         self._remote.sync_fetch(url, refs=commit_ids)
         self._remote.invalidate_vcs_cache()
 
     def push(self, url):
         refs = None
         self._remote.sync_push(url, refs=refs)
 
     def set_refs(self, ref_name, commit_id):
         self._remote.set_refs(ref_name, commit_id)
         self._invalidate_prop_cache('_refs')
 
     def remove_ref(self, ref_name):
         self._remote.remove_ref(ref_name)
         self._invalidate_prop_cache('_refs')
 
     def _update_server_info(self):
         """
         runs gits update-server-info command in this repo instance
         """
         self._remote.update_server_info()
 
     def _current_branch(self):
         """
         Return the name of the current branch.
 
         It only works for non bare repositories (i.e. repositories with a
         working copy)
         """
         if self.bare:
             raise RepositoryError('Bare git repos do not have active branches')
 
         if self.is_empty():
             return None
 
         stdout, _ = self.run_git_command(['rev-parse', '--abbrev-ref', 'HEAD'])
         return stdout.strip()
 
     def _checkout(self, branch_name, create=False, force=False):
         """
         Checkout a branch in the working directory.
 
         It tries to create the branch if create is True, failing if the branch
         already exists.
 
         It only works for non bare repositories (i.e. repositories with a
         working copy)
         """
         if self.bare:
             raise RepositoryError('Cannot checkout branches in a bare git repo')
 
         cmd = ['checkout']
         if force:
             cmd.append('-f')
         if create:
             cmd.append('-b')
         cmd.append(branch_name)
         self.run_git_command(cmd, fail_on_stderr=False)
 
     def _create_branch(self, branch_name, commit_id):
         """
         creates a branch in a GIT repo
         """
         self._remote.create_branch(branch_name, commit_id)
 
     def _identify(self):
         """
         Return the current state of the working directory.
         """
         if self.bare:
             raise RepositoryError('Bare git repos do not have active branches')
 
         if self.is_empty():
             return None
 
         stdout, _ = self.run_git_command(['rev-parse', 'HEAD'])
         return stdout.strip()
 
     def _local_clone(self, clone_path, branch_name, source_branch=None):
         """
         Create a local clone of the current repo.
         """
         # N.B.(skreft): the --branch option is required as otherwise the shallow
         # clone will only fetch the active branch.
         cmd = ['clone', '--branch', branch_name,
                self.path, os.path.abspath(clone_path)]
 
         self.run_git_command(cmd, fail_on_stderr=False)
 
         # if we get the different source branch, make sure we also fetch it for
         # merge conditions
         if source_branch and source_branch != branch_name:
             # check if the ref exists.
             shadow_repo = GitRepository(os.path.abspath(clone_path))
             if shadow_repo.get_remote_ref(source_branch):
                 cmd = ['fetch', self.path, source_branch]
                 self.run_git_command(cmd, fail_on_stderr=False)
 
     def _local_fetch(self, repository_path, branch_name, use_origin=False):
         """
         Fetch a branch from a local repository.
         """
         repository_path = os.path.abspath(repository_path)
         if repository_path == self.path:
             raise ValueError('Cannot fetch from the same repository')
 
         if use_origin:
             branch_name = '+{branch}:refs/heads/{branch}'.format(
                 branch=branch_name)
 
         cmd = ['fetch', '--no-tags', '--update-head-ok',
                repository_path, branch_name]
         self.run_git_command(cmd, fail_on_stderr=False)
 
     def _local_reset(self, branch_name):
         branch_name = '{}'.format(branch_name)
         cmd = ['reset', '--hard', branch_name, '--']
         self.run_git_command(cmd, fail_on_stderr=False)
 
     def _last_fetch_heads(self):
         """
         Return the last fetched heads that need merging.
 
         The algorithm is defined at
         https://github.com/git/git/blob/v2.1.3/git-pull.sh#L283
         """
         if not self.bare:
             fetch_heads_path = os.path.join(self.path, '.git', 'FETCH_HEAD')
         else:
             fetch_heads_path = os.path.join(self.path, 'FETCH_HEAD')
 
         heads = []
         with open(fetch_heads_path) as f:
             for line in f:
                 if '    not-for-merge   ' in line:
                     continue
                 line = re.sub('\t.*', '', line, flags=re.DOTALL)
                 heads.append(line)
 
         return heads
 
     def get_shadow_instance(self, shadow_repository_path, enable_hooks=False, cache=False):
         return GitRepository(shadow_repository_path, with_wire={"cache": cache})
 
     def _local_pull(self, repository_path, branch_name, ff_only=True):
         """
         Pull a branch from a local repository.
         """
         if self.bare:
             raise RepositoryError('Cannot pull into a bare git repository')
         # N.B.(skreft): The --ff-only option is to make sure this is a
         # fast-forward (i.e., we are only pulling new changes and there are no
         # conflicts with our current branch)
         # Additionally, that option needs to go before --no-tags, otherwise git
         # pull complains about it being an unknown flag.
         cmd = ['pull']
         if ff_only:
             cmd.append('--ff-only')
         cmd.extend(['--no-tags', repository_path, branch_name])
         self.run_git_command(cmd, fail_on_stderr=False)
 
     def _local_merge(self, merge_message, user_name, user_email, heads):
         """
         Merge the given head into the checked out branch.
 
         It will force a merge commit.
 
         Currently it raises an error if the repo is empty, as it is not possible
         to create a merge commit in an empty repo.
 
         :param merge_message: The message to use for the merge commit.
         :param heads: the heads to merge.
         """
         if self.bare:
             raise RepositoryError('Cannot merge into a bare git repository')
 
         if not heads:
             return
 
         if self.is_empty():
             # TODO(skreft): do somehting more robust in this case.
             raise RepositoryError(
                 'Do not know how to merge into empty repositories yet')
 
         # N.B.(skreft): the --no-ff option is used to enforce the creation of a
         # commit message. We also specify the user who is doing the merge.
         cmd = ['-c', 'user.name="%s"' % safe_str(user_name),
                '-c', 'user.email=%s' % safe_str(user_email),
                'merge', '--no-ff', '-m', safe_str(merge_message)]
         cmd.extend(heads)
         try:
             output = self.run_git_command(cmd, fail_on_stderr=False)
         except RepositoryError:
             # Cleanup any merge leftovers
             self.run_git_command(['merge', '--abort'], fail_on_stderr=False)
             raise
 
     def _local_push(
             self, source_branch, repository_path, target_branch,
             enable_hooks=False, rc_scm_data=None):
         """
         Push the source_branch to the given repository and target_branch.
 
         Currently it if the target_branch is not master and the target repo is
         empty, the push will work, but then GitRepository won't be able to find
         the pushed branch or the commits. As the HEAD will be corrupted (i.e.,
         pointing to master, which does not exist).
 
         It does not run the hooks in the target repo.
         """
         # TODO(skreft): deal with the case in which the target repo is empty,
         # and the target_branch is not master.
         target_repo = GitRepository(repository_path)
         if (not target_repo.bare and
                 target_repo._current_branch() == target_branch):
             # Git prevents pushing to the checked out branch, so simulate it by
             # pulling into the target repository.
             target_repo._local_pull(self.path, source_branch)
         else:
             cmd = ['push', os.path.abspath(repository_path),
                    '%s:%s' % (source_branch, target_branch)]
             gitenv = {}
             if rc_scm_data:
                 gitenv.update({'RC_SCM_DATA': rc_scm_data})
 
             if not enable_hooks:
                 gitenv['RC_SKIP_HOOKS'] = '1'
             self.run_git_command(cmd, fail_on_stderr=False, extra_env=gitenv)
 
     def _get_new_pr_branch(self, source_branch, target_branch):
         prefix = 'pr_%s-%s_' % (source_branch, target_branch)
         pr_branches = []
         for branch in self.branches:
             if branch.startswith(prefix):
                 pr_branches.append(int(branch[len(prefix):]))
 
         if not pr_branches:
             branch_id = 0
         else:
             branch_id = max(pr_branches) + 1
 
         return '%s%d' % (prefix, branch_id)
 
     def _maybe_prepare_merge_workspace(
             self, repo_id, workspace_id, target_ref, source_ref):
         shadow_repository_path = self._get_shadow_repository_path(
             repo_id, workspace_id)
         if not os.path.exists(shadow_repository_path):
             self._local_clone(
                 shadow_repository_path, target_ref.name, source_ref.name)
             log.debug('Prepared %s shadow repository in %s',
                       self.alias, shadow_repository_path)
 
         return shadow_repository_path
 
     def _merge_repo(self, repo_id, workspace_id, target_ref,
                     source_repo, source_ref, merge_message,
                     merger_name, merger_email, dry_run=False,
                     use_rebase=False, close_branch=False):
 
         log.debug('Executing merge_repo with %s strategy, dry_run mode:%s',
                   'rebase' if use_rebase else 'merge', dry_run)
         if target_ref.commit_id != self.branches[target_ref.name]:
             log.warning('Target ref %s commit mismatch %s vs %s', target_ref,
                         target_ref.commit_id, self.branches[target_ref.name])
             return MergeResponse(
                 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD,
                 metadata={'target_ref': target_ref})
 
         shadow_repository_path = self._maybe_prepare_merge_workspace(
             repo_id, workspace_id, target_ref, source_ref)
         shadow_repo = self.get_shadow_instance(shadow_repository_path)
 
         # checkout source, if it's different. Otherwise we could not
         # fetch proper commits for merge testing
         if source_ref.name != target_ref.name:
             if shadow_repo.get_remote_ref(source_ref.name):
                 shadow_repo._checkout(source_ref.name, force=True)
 
         # checkout target, and fetch changes
         shadow_repo._checkout(target_ref.name, force=True)
 
         # fetch/reset pull the target, in case it is changed
         # this handles even force changes
         shadow_repo._local_fetch(self.path, target_ref.name, use_origin=True)
         shadow_repo._local_reset(target_ref.name)
 
         # Need to reload repo to invalidate the cache, or otherwise we cannot
         # retrieve the last target commit.
         shadow_repo = self.get_shadow_instance(shadow_repository_path)
         if target_ref.commit_id != shadow_repo.branches[target_ref.name]:
             log.warning('Shadow Target ref %s commit mismatch %s vs %s',
                         target_ref, target_ref.commit_id,
                         shadow_repo.branches[target_ref.name])
             return MergeResponse(
                 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD,
                 metadata={'target_ref': target_ref})
 
         # calculate new branch
         pr_branch = shadow_repo._get_new_pr_branch(
             source_ref.name, target_ref.name)
         log.debug('using pull-request merge branch: `%s`', pr_branch)
         # checkout to temp branch, and fetch changes
         shadow_repo._checkout(pr_branch, create=True)
         try:
             shadow_repo._local_fetch(source_repo.path, source_ref.name)
         except RepositoryError:
             log.exception('Failure when doing local fetch on '
                           'shadow repo: %s', shadow_repo)
             return MergeResponse(
                 False, False, None, MergeFailureReason.MISSING_SOURCE_REF,
                 metadata={'source_ref': source_ref})
 
         merge_ref = None
         merge_failure_reason = MergeFailureReason.NONE
         metadata = {}
         try:
             shadow_repo._local_merge(merge_message, merger_name, merger_email,
                                      [source_ref.commit_id])
             merge_possible = True
 
             # Need to invalidate the cache, or otherwise we
             # cannot retrieve the merge commit.
             shadow_repo = shadow_repo.get_shadow_instance(shadow_repository_path)
             merge_commit_id = shadow_repo.branches[pr_branch]
 
             # Set a reference pointing to the merge commit. This reference may
             # be used to easily identify the last successful merge commit in
             # the shadow repository.
             shadow_repo.set_refs('refs/heads/pr-merge', merge_commit_id)
             merge_ref = Reference('branch', 'pr-merge', merge_commit_id)
         except RepositoryError:
             log.exception('Failure when doing local merge on git shadow repo')
             merge_possible = False
             merge_failure_reason = MergeFailureReason.MERGE_FAILED
 
         if merge_possible and not dry_run:
             try:
                 shadow_repo._local_push(
                     pr_branch, self.path, target_ref.name, enable_hooks=True,
                     rc_scm_data=self.config.get('rhodecode', 'RC_SCM_DATA'))
                 merge_succeeded = True
             except RepositoryError:
                 log.exception(
                     'Failure when doing local push from the shadow '
                     'repository to the target repository at %s.', self.path)
                 merge_succeeded = False
                 merge_failure_reason = MergeFailureReason.PUSH_FAILED
                 metadata['target'] = 'git shadow repo'
                 metadata['merge_commit'] = pr_branch
         else:
             merge_succeeded = False
 
         return MergeResponse(
             merge_possible, merge_succeeded, merge_ref, merge_failure_reason,
             metadata=metadata)

rhodecode/lib/vcs/backends/hg/commit.py

@@ -1,381 +1,380 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 HG commit module
 """
 
 import os
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.lib.datelib import utcdate_fromtimestamp
 from rhodecode.lib.utils import safe_str, safe_unicode
 from rhodecode.lib.vcs import path as vcspath
 from rhodecode.lib.vcs.backends import base
 from rhodecode.lib.vcs.backends.hg.diff import MercurialDiff
 from rhodecode.lib.vcs.exceptions import CommitError
 from rhodecode.lib.vcs.nodes import (
     AddedFileNodesGenerator, ChangedFileNodesGenerator, DirNode, FileNode,
     NodeKind, RemovedFileNodesGenerator, RootNode, SubModuleNode,
     LargeFileNode, LARGEFILE_PREFIX)
 from rhodecode.lib.vcs.utils.paths import get_dirs_for_path
 
 
 class MercurialCommit(base.BaseCommit):
     """
     Represents state of the repository at the single commit.
     """
 
     _filter_pre_load = [
         # git specific property not supported here
         "_commit",
     ]
 
     def __init__(self, repository, raw_id, idx, pre_load=None):
         raw_id = safe_str(raw_id)
 
         self.repository = repository
         self._remote = repository._remote
 
         self.raw_id = raw_id
         self.idx = idx
 
         self._set_bulk_properties(pre_load)
 
         # caches
         self.nodes = {}
 
     def _set_bulk_properties(self, pre_load):
         if not pre_load:
             return
         pre_load = [entry for entry in pre_load
                     if entry not in self._filter_pre_load]
         if not pre_load:
             return
 
         result = self._remote.bulk_request(self.raw_id, pre_load)
         for attr, value in result.items():
             if attr in ["author", "branch", "message"]:
                 value = safe_unicode(value)
             elif attr == "affected_files":
                 value = map(safe_unicode, value)
             elif attr == "date":
                 value = utcdate_fromtimestamp(*value)
             elif attr in ["children", "parents"]:
                 value = self._make_commits(value)
             elif attr in ["phase"]:
                 value = self._get_phase_text(value)
             self.__dict__[attr] = value
 
     @LazyProperty
     def tags(self):
         tags = [name for name, commit_id in self.repository.tags.iteritems()
                 if commit_id == self.raw_id]
         return tags
 
     @LazyProperty
     def branch(self):
         return safe_unicode(self._remote.ctx_branch(self.raw_id))
 
     @LazyProperty
     def bookmarks(self):
         bookmarks = [
             name for name, commit_id in self.repository.bookmarks.iteritems()
             if commit_id == self.raw_id]
         return bookmarks
 
     @LazyProperty
     def message(self):
         return safe_unicode(self._remote.ctx_description(self.raw_id))
 
     @LazyProperty
     def committer(self):
         return safe_unicode(self.author)
 
     @LazyProperty
     def author(self):
         return safe_unicode(self._remote.ctx_user(self.raw_id))
 
     @LazyProperty
     def date(self):
         return utcdate_fromtimestamp(*self._remote.ctx_date(self.raw_id))
 
     @LazyProperty
     def status(self):
         """
         Returns modified, added, removed, deleted files for current commit
         """
         return self._remote.ctx_status(self.raw_id)
 
     @LazyProperty
     def _file_paths(self):
         return self._remote.ctx_list(self.raw_id)
 
     @LazyProperty
     def _dir_paths(self):
         p = list(set(get_dirs_for_path(*self._file_paths)))
         p.insert(0, '')
         return p
 
     @LazyProperty
     def _paths(self):
         return self._dir_paths + self._file_paths
 
     @LazyProperty
     def id(self):
         if self.last:
             return u'tip'
         return self.short_id
 
     @LazyProperty
     def short_id(self):
         return self.raw_id[:12]
 
     def _make_commits(self, indexes, pre_load=None):
         return [self.repository.get_commit(commit_idx=idx, pre_load=pre_load)
                 for idx in indexes if idx >= 0]
 
     @LazyProperty
     def parents(self):
         """
         Returns list of parent commits.
         """
         parents = self._remote.ctx_parents(self.raw_id)
         return self._make_commits(parents)
 
     def _get_phase_text(self, phase_id):
         return {
                    0: 'public',
                    1: 'draft',
                    2: 'secret',
                }.get(phase_id) or ''
 
     @LazyProperty
     def phase(self):
         phase_id = self._remote.ctx_phase(self.raw_id)
         phase_text = self._get_phase_text(phase_id)
 
         return safe_unicode(phase_text)
 
     @LazyProperty
     def obsolete(self):
         obsolete = self._remote.ctx_obsolete(self.raw_id)
         return obsolete
 
     @LazyProperty
     def hidden(self):
         hidden = self._remote.ctx_hidden(self.raw_id)
         return hidden
 
     @LazyProperty
     def children(self):
         """
         Returns list of child commits.
         """
         children = self._remote.ctx_children(self.raw_id)
         return self._make_commits(children)
 
     def _fix_path(self, path):
         """
         Mercurial keeps filenodes as str so we need to encode from unicode
         to str.
         """
         return safe_str(super(MercurialCommit, self)._fix_path(path))
 
     def _get_kind(self, path):
         path = self._fix_path(path)
         if path in self._file_paths:
             return NodeKind.FILE
         elif path in self._dir_paths:
             return NodeKind.DIR
         else:
             raise CommitError(
                 "Node does not exist at the given path '%s'" % (path, ))
 
     def _get_filectx(self, path):
         path = self._fix_path(path)
         if self._get_kind(path) != NodeKind.FILE:
             raise CommitError(
                 "File does not exist for idx %s at '%s'" % (self.raw_id, path))
         return path
 
     def get_file_mode(self, path):
         """
         Returns stat mode of the file at the given ``path``.
         """
         path = self._get_filectx(path)
         if 'x' in self._remote.fctx_flags(self.raw_id, path):
             return base.FILEMODE_EXECUTABLE
         else:
             return base.FILEMODE_DEFAULT
 
     def is_link(self, path):
         path = self._get_filectx(path)
         return 'l' in self._remote.fctx_flags(self.raw_id, path)
 
     def get_file_content(self, path):
         """
         Returns content of the file at given ``path``.
         """
         path = self._get_filectx(path)
         return self._remote.fctx_node_data(self.raw_id, path)
 
     def get_file_size(self, path):
         """
         Returns size of the file at given ``path``.
         """
         path = self._get_filectx(path)
         return self._remote.fctx_size(self.raw_id, path)
 
     def get_path_history(self, path, limit=None, pre_load=None):
         """
         Returns history of file as reversed list of `MercurialCommit` objects
         for which file at given ``path`` has been modified.
         """
         path = self._get_filectx(path)
         hist = self._remote.node_history(self.raw_id, path, limit)
         return [
             self.repository.get_commit(commit_id=commit_id, pre_load=pre_load)
             for commit_id in hist]
 
     def get_file_annotate(self, path, pre_load=None):
         """
         Returns a generator of four element tuples with
             lineno, commit_id, commit lazy loader and line
         """
         result = self._remote.fctx_annotate(self.raw_id, path)
 
         for ln_no, commit_id, content in result:
             yield (
                 ln_no, commit_id,
-                lambda: self.repository.get_commit(commit_id=commit_id,
-                                                   pre_load=pre_load),
+                lambda: self.repository.get_commit(commit_id=commit_id, pre_load=pre_load),
                 content)
 
     def get_nodes(self, path):
         """
         Returns combined ``DirNode`` and ``FileNode`` objects list representing
         state of commit at the given ``path``. If node at the given ``path``
         is not instance of ``DirNode``, CommitError would be raised.
         """
 
         if self._get_kind(path) != NodeKind.DIR:
             raise CommitError(
                 "Directory does not exist for idx %s at '%s'" % (self.raw_id, path))
         path = self._fix_path(path)
 
         filenodes = [
             FileNode(f, commit=self) for f in self._file_paths
             if os.path.dirname(f) == path]
         # TODO: johbo: Check if this can be done in a more obvious way
         dirs = path == '' and '' or [
             d for d in self._dir_paths
             if d and vcspath.dirname(d) == path]
         dirnodes = [
             DirNode(d, commit=self) for d in dirs
             if os.path.dirname(d) == path]
 
         alias = self.repository.alias
         for k, vals in self._submodules.iteritems():
             if vcspath.dirname(k) == path:
                 loc = vals[0]
                 commit = vals[1]
                 dirnodes.append(SubModuleNode(k, url=loc, commit=commit, alias=alias))
 
         nodes = dirnodes + filenodes
         for node in nodes:
             if node.path not in self.nodes:
                 self.nodes[node.path] = node
         nodes.sort()
 
         return nodes
 
     def get_node(self, path, pre_load=None):
         """
         Returns `Node` object from the given `path`. If there is no node at
         the given `path`, `NodeDoesNotExistError` would be raised.
         """
         path = self._fix_path(path)
 
         if path not in self.nodes:
             if path in self._file_paths:
                 node = FileNode(path, commit=self, pre_load=pre_load)
             elif path in self._dir_paths:
                 if path == '':
                     node = RootNode(commit=self)
                 else:
                     node = DirNode(path, commit=self)
             else:
                 raise self.no_node_at_path(path)
 
             # cache node
             self.nodes[path] = node
         return self.nodes[path]
 
     def get_largefile_node(self, path):
 
         if self._remote.is_large_file(path):
             # content of that file regular FileNode is the hash of largefile
             file_id = self.get_file_content(path).strip()
 
             if self._remote.in_largefiles_store(file_id):
                 lf_path = self._remote.store_path(file_id)
                 return LargeFileNode(lf_path, commit=self, org_path=path)
             elif self._remote.in_user_cache(file_id):
                 lf_path = self._remote.store_path(file_id)
                 self._remote.link(file_id, path)
                 return LargeFileNode(lf_path, commit=self, org_path=path)
 
     @LazyProperty
     def _submodules(self):
         """
         Returns a dictionary with submodule information from substate file
         of hg repository.
         """
         return self._remote.ctx_substate(self.raw_id)
 
     @LazyProperty
     def affected_files(self):
         """
         Gets a fast accessible file changes for given commit
         """
         return self._remote.ctx_files(self.raw_id)
 
     @property
     def added(self):
         """
         Returns list of added ``FileNode`` objects.
         """
         return AddedFileNodesGenerator([n for n in self.status[1]], self)
 
     @property
     def changed(self):
         """
         Returns list of modified ``FileNode`` objects.
         """
         return ChangedFileNodesGenerator([n for n in self.status[0]], self)
 
     @property
     def removed(self):
         """
         Returns list of removed ``FileNode`` objects.
         """
         return RemovedFileNodesGenerator([n for n in self.status[2]], self)

rhodecode/tests/vcs/test_git.py

@@ -1,1276 +1,1274 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import datetime
 import mock
 import os
 import sys
 import shutil
 
 import pytest
 
 from rhodecode.lib.utils import make_db_config
 from rhodecode.lib.vcs.backends.base import Reference
 from rhodecode.lib.vcs.backends.git import (
     GitRepository, GitCommit, discover_git_version)
 from rhodecode.lib.vcs.exceptions import (
     RepositoryError, VCSError, NodeDoesNotExistError)
 from rhodecode.lib.vcs.nodes import (
     NodeKind, FileNode, DirNode, NodeState, SubModuleNode)
 from rhodecode.tests import TEST_GIT_REPO, TEST_GIT_REPO_CLONE, get_new_dir
 from rhodecode.tests.vcs.conftest import BackendTestMixin
 
 
 pytestmark = pytest.mark.backends("git")
 
 
 class TestGitRepository(object):
 
     @pytest.fixture(autouse=True)
     def prepare(self, request, baseapp):
         self.repo = GitRepository(TEST_GIT_REPO, bare=True)
         self.repo.count()
 
     def get_clone_repo(self, tmp_path_factory):
         """
         Return a non bare clone of the base repo.
         """
         clone_path = tmp_path_factory.mktemp('clone-url')
         repo_clone = GitRepository(
             clone_path, create=True, src_url=self.repo.path, bare=False)
 
         return repo_clone
 
     def get_empty_repo(self, tmp_path_factory, bare=False):
         """
         Return a non bare empty repo.
         """
         clone_path = tmp_path_factory.mktemp('empty-repo')
         return GitRepository(clone_path, create=True, bare=bare)
 
     def test_wrong_repo_path(self):
         wrong_repo_path = '/tmp/errorrepo_git'
         with pytest.raises(RepositoryError):
             GitRepository(wrong_repo_path)
 
     def test_repo_clone(self, tmp_path_factory):
         repo = GitRepository(TEST_GIT_REPO)
         clone_path = tmp_path_factory.mktemp('_') + '_' + TEST_GIT_REPO_CLONE
         repo_clone = GitRepository(
             clone_path,
             src_url=TEST_GIT_REPO, create=True, do_workspace_checkout=True)
 
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
         # Checking hashes of commits should be enough
         for commit in repo.get_commits():
             raw_id = commit.raw_id
             assert raw_id == repo_clone.get_commit(raw_id).raw_id
 
     def test_repo_clone_without_create(self):
         with pytest.raises(RepositoryError):
             GitRepository(
                 TEST_GIT_REPO_CLONE + '_wo_create', src_url=TEST_GIT_REPO)
 
     def test_repo_clone_with_update(self, tmp_path_factory):
         repo = GitRepository(TEST_GIT_REPO)
         clone_path = tmp_path_factory.mktemp('_') + '_' + TEST_GIT_REPO_CLONE + '_update'
 
         repo_clone = GitRepository(
             clone_path,
             create=True, src_url=TEST_GIT_REPO, do_workspace_checkout=True)
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
 
         # check if current workdir was updated
         fpath = os.path.join(clone_path, 'MANIFEST.in')
         assert os.path.isfile(fpath)
 
     def test_repo_clone_without_update(self, tmp_path_factory):
         repo = GitRepository(TEST_GIT_REPO)
         clone_path = tmp_path_factory.mktemp('_') + '_' + TEST_GIT_REPO_CLONE + '_without_update'
         repo_clone = GitRepository(
             clone_path,
             create=True, src_url=TEST_GIT_REPO, do_workspace_checkout=False)
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
         # check if current workdir was *NOT* updated
         fpath = os.path.join(clone_path, 'MANIFEST.in')
         # Make sure it's not bare repo
         assert not repo_clone.bare
         assert not os.path.isfile(fpath)
 
     def test_repo_clone_into_bare_repo(self, tmp_path_factory):
         repo = GitRepository(TEST_GIT_REPO)
         clone_path = tmp_path_factory.mktemp('_') + '_' + TEST_GIT_REPO_CLONE + '_bare.git'
         repo_clone = GitRepository(
             clone_path, create=True, src_url=repo.path, bare=True)
         assert repo_clone.bare
 
     def test_create_repo_is_not_bare_by_default(self):
         repo = GitRepository(get_new_dir('not-bare-by-default'), create=True)
         assert not repo.bare
 
     def test_create_bare_repo(self):
         repo = GitRepository(get_new_dir('bare-repo'), create=True, bare=True)
         assert repo.bare
 
     def test_update_server_info(self):
         self.repo._update_server_info()
 
     def test_fetch(self, vcsbackend_git):
         # Note: This is a git specific part of the API, it's only implemented
         # by the git backend.
         source_repo = vcsbackend_git.repo
         target_repo = vcsbackend_git.create_repo(bare=True)
         target_repo.fetch(source_repo.path)
         # Note: Get a fresh instance, avoids caching trouble
         target_repo = vcsbackend_git.backend(target_repo.path)
         assert len(source_repo.commit_ids) == len(target_repo.commit_ids)
 
     def test_commit_ids(self):
         # there are 112 commits (by now)
         # so we can assume they would be available from now on
         subset = {'c1214f7e79e02fc37156ff215cd71275450cffc3',
                   '38b5fe81f109cb111f549bfe9bb6b267e10bc557',
                   'fa6600f6848800641328adbf7811fd2372c02ab2',
                   '102607b09cdd60e2793929c4f90478be29f85a17',
                   '49d3fd156b6f7db46313fac355dca1a0b94a0017',
                   '2d1028c054665b962fa3d307adfc923ddd528038',
                   'd7e0d30fbcae12c90680eb095a4f5f02505ce501',
                   'ff7ca51e58c505fec0dd2491de52c622bb7a806b',
                   'dd80b0f6cf5052f17cc738c2951c4f2070200d7f',
                   '8430a588b43b5d6da365400117c89400326e7992',
                   'd955cd312c17b02143c04fa1099a352b04368118',
                   'f67b87e5c629c2ee0ba58f85197e423ff28d735b',
                   'add63e382e4aabc9e1afdc4bdc24506c269b7618',
                   'f298fe1189f1b69779a4423f40b48edf92a703fc',
                   'bd9b619eb41994cac43d67cf4ccc8399c1125808',
                   '6e125e7c890379446e98980d8ed60fba87d0f6d1',
                   'd4a54db9f745dfeba6933bf5b1e79e15d0af20bd',
                   '0b05e4ed56c802098dfc813cbe779b2f49e92500',
                   '191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e',
                   '45223f8f114c64bf4d6f853e3c35a369a6305520',
                   'ca1eb7957a54bce53b12d1a51b13452f95bc7c7e',
                   'f5ea29fc42ef67a2a5a7aecff10e1566699acd68',
                   '27d48942240f5b91dfda77accd2caac94708cc7d',
                   '622f0eb0bafd619d2560c26f80f09e3b0b0d78af',
                   'e686b958768ee96af8029fe19c6050b1a8dd3b2b'}
         assert subset.issubset(set(self.repo.commit_ids))
 
     def test_slicing(self):
         # 4 1 5 10 95
         for sfrom, sto, size in [(0, 4, 4), (1, 2, 1), (10, 15, 5),
                                  (10, 20, 10), (5, 100, 95)]:
             commit_ids = list(self.repo[sfrom:sto])
             assert len(commit_ids) == size
             assert commit_ids[0] == self.repo.get_commit(commit_idx=sfrom)
             assert commit_ids[-1] == self.repo.get_commit(commit_idx=sto - 1)
 
     def test_branches(self):
         # TODO: Need more tests here
         # Removed (those are 'remotes' branches for cloned repo)
         # assert 'master' in self.repo.branches
         # assert 'gittree' in self.repo.branches
         # assert 'web-branch' in self.repo.branches
         for __, commit_id in self.repo.branches.items():
             assert isinstance(self.repo.get_commit(commit_id), GitCommit)
 
     def test_tags(self):
         # TODO: Need more tests here
         assert 'v0.1.1' in self.repo.tags
         assert 'v0.1.2' in self.repo.tags
         for __, commit_id in self.repo.tags.items():
             assert isinstance(self.repo.get_commit(commit_id), GitCommit)
 
     def _test_single_commit_cache(self, commit_id):
         commit = self.repo.get_commit(commit_id)
         assert commit_id in self.repo.commits
         assert commit is self.repo.commits[commit_id]
 
     def test_initial_commit(self):
         commit_id = self.repo.commit_ids[0]
         init_commit = self.repo.get_commit(commit_id)
         init_author = init_commit.author
 
         assert init_commit.message == 'initial import\n'
         assert init_author == 'Marcin Kuzminski <[e-mail]>'
         assert init_author == init_commit.committer
         for path in ('vcs/__init__.py',
                      'vcs/backends/BaseRepository.py',
                      'vcs/backends/__init__.py'):
             assert isinstance(init_commit.get_node(path), FileNode)
         for path in ('', 'vcs', 'vcs/backends'):
             assert isinstance(init_commit.get_node(path), DirNode)
 
         with pytest.raises(NodeDoesNotExistError):
             init_commit.get_node(path='foobar')
 
         node = init_commit.get_node('vcs/')
         assert hasattr(node, 'kind')
         assert node.kind == NodeKind.DIR
 
         node = init_commit.get_node('vcs')
         assert hasattr(node, 'kind')
         assert node.kind == NodeKind.DIR
 
         node = init_commit.get_node('vcs/__init__.py')
         assert hasattr(node, 'kind')
         assert node.kind == NodeKind.FILE
 
     def test_not_existing_commit(self):
         with pytest.raises(RepositoryError):
             self.repo.get_commit('f' * 40)
 
     def test_commit10(self):
 
         commit10 = self.repo.get_commit(self.repo.commit_ids[9])
         README = """===
 VCS
 ===
 
 Various Version Control System management abstraction layer for Python.
 
 Introduction
 ------------
 
 TODO: To be written...
 
 """
         node = commit10.get_node('README.rst')
         assert node.kind == NodeKind.FILE
         assert node.content == README
 
     def test_head(self):
         assert self.repo.head == self.repo.get_commit().raw_id
 
     def test_checkout_with_create(self, tmp_path_factory):
         repo_clone = self.get_clone_repo(tmp_path_factory)
 
         new_branch = 'new_branch'
         assert repo_clone._current_branch() == 'master'
         assert set(repo_clone.branches) == {'master'}
         repo_clone._checkout(new_branch, create=True)
 
         # Branches is a lazy property so we need to recrete the Repo object.
         repo_clone = GitRepository(repo_clone.path)
         assert set(repo_clone.branches) == {'master', new_branch}
         assert repo_clone._current_branch() == new_branch
 
     def test_checkout(self, tmp_path_factory):
         repo_clone = self.get_clone_repo(tmp_path_factory)
 
         repo_clone._checkout('new_branch', create=True)
         repo_clone._checkout('master')
 
         assert repo_clone._current_branch() == 'master'
 
     def test_checkout_same_branch(self, tmp_path_factory):
         repo_clone = self.get_clone_repo(tmp_path_factory)
 
         repo_clone._checkout('master')
         assert repo_clone._current_branch() == 'master'
 
     def test_checkout_branch_already_exists(self, tmp_path_factory):
         repo_clone = self.get_clone_repo(tmp_path_factory)
 
         with pytest.raises(RepositoryError):
             repo_clone._checkout('master', create=True)
 
     def test_checkout_bare_repo(self):
         with pytest.raises(RepositoryError):
             self.repo._checkout('master')
 
     def test_current_branch_bare_repo(self):
         with pytest.raises(RepositoryError):
             self.repo._current_branch()
 
     def test_current_branch_empty_repo(self, tmp_path_factory):
         repo = self.get_empty_repo(tmp_path_factory)
         assert repo._current_branch() is None
 
     def test_local_clone(self, tmp_path_factory):
         clone_path = tmp_path_factory.mktemp('test-local-clone')
         self.repo._local_clone(clone_path, 'master')
         repo_clone = GitRepository(clone_path)
 
         assert self.repo.commit_ids == repo_clone.commit_ids
 
     def test_local_clone_with_specific_branch(self, tmp_path_factory):
         source_repo = self.get_clone_repo(tmp_path_factory)
 
         # Create a new branch in source repo
         new_branch_commit = source_repo.commit_ids[-3]
         source_repo._checkout(new_branch_commit)
         source_repo._checkout('new_branch', create=True)
 
         clone_path = tmp_path_factory.mktemp('git-clone-path-1')
         source_repo._local_clone(clone_path, 'new_branch')
         repo_clone = GitRepository(clone_path)
 
         assert source_repo.commit_ids[:-3 + 1] == repo_clone.commit_ids
 
         clone_path = tmp_path_factory.mktemp('git-clone-path-2')
         source_repo._local_clone(clone_path, 'master')
         repo_clone = GitRepository(clone_path)
 
         assert source_repo.commit_ids == repo_clone.commit_ids
 
     def test_local_clone_fails_if_target_exists(self):
         with pytest.raises(RepositoryError):
             self.repo._local_clone(self.repo.path, 'master')
 
     def test_local_fetch(self, tmp_path_factory):
         target_repo = self.get_empty_repo(tmp_path_factory)
         source_repo = self.get_clone_repo(tmp_path_factory)
 
         # Create a new branch in source repo
         master_commit = source_repo.commit_ids[-1]
         new_branch_commit = source_repo.commit_ids[-3]
         source_repo._checkout(new_branch_commit)
         source_repo._checkout('new_branch', create=True)
 
         target_repo._local_fetch(source_repo.path, 'new_branch')
         assert target_repo._last_fetch_heads() == [new_branch_commit]
 
         target_repo._local_fetch(source_repo.path, 'master')
         assert target_repo._last_fetch_heads() == [master_commit]
 
     def test_local_fetch_from_bare_repo(self, tmp_path_factory):
         target_repo = self.get_empty_repo(tmp_path_factory)
         target_repo._local_fetch(self.repo.path, 'master')
 
         master_commit = self.repo.commit_ids[-1]
         assert target_repo._last_fetch_heads() == [master_commit]
 
     def test_local_fetch_from_same_repo(self):
         with pytest.raises(ValueError):
             self.repo._local_fetch(self.repo.path, 'master')
 
     def test_local_fetch_branch_does_not_exist(self, tmp_path_factory):
         target_repo = self.get_empty_repo(tmp_path_factory)
 
         with pytest.raises(RepositoryError):
             target_repo._local_fetch(self.repo.path, 'new_branch')
 
     def test_local_pull(self, tmp_path_factory):
         target_repo = self.get_empty_repo(tmp_path_factory)
         source_repo = self.get_clone_repo(tmp_path_factory)
 
         # Create a new branch in source repo
         master_commit = source_repo.commit_ids[-1]
         new_branch_commit = source_repo.commit_ids[-3]
         source_repo._checkout(new_branch_commit)
         source_repo._checkout('new_branch', create=True)
 
         target_repo._local_pull(source_repo.path, 'new_branch')
         target_repo = GitRepository(target_repo.path)
         assert target_repo.head == new_branch_commit
 
         target_repo._local_pull(source_repo.path, 'master')
         target_repo = GitRepository(target_repo.path)
         assert target_repo.head == master_commit
 
     def test_local_pull_in_bare_repo(self):
         with pytest.raises(RepositoryError):
             self.repo._local_pull(self.repo.path, 'master')
 
     def test_local_merge(self, tmp_path_factory):
         target_repo = self.get_empty_repo(tmp_path_factory)
         source_repo = self.get_clone_repo(tmp_path_factory)
 
         # Create a new branch in source repo
         master_commit = source_repo.commit_ids[-1]
         new_branch_commit = source_repo.commit_ids[-3]
         source_repo._checkout(new_branch_commit)
         source_repo._checkout('new_branch', create=True)
 
         # This is required as one cannot do a -ff-only merge in an empty repo.
         target_repo._local_pull(source_repo.path, 'new_branch')
 
         target_repo._local_fetch(source_repo.path, 'master')
         merge_message = 'Merge message\n\nDescription:...'
         user_name = 'Albert Einstein'
         user_email = '[e-mail]'
         target_repo._local_merge(merge_message, user_name, user_email,
                                  target_repo._last_fetch_heads())
 
         target_repo = GitRepository(target_repo.path)
         assert target_repo.commit_ids[-2] == master_commit
         last_commit = target_repo.get_commit(target_repo.head)
         assert last_commit.message.strip() == merge_message
         assert last_commit.author == '%s <%s>' % (user_name, user_email)
 
         assert not os.path.exists(
             os.path.join(target_repo.path, '.git', 'MERGE_HEAD'))
 
     def test_local_merge_raises_exception_on_conflict(self, vcsbackend_git):
         target_repo = vcsbackend_git.create_repo(number_of_commits=1)
         vcsbackend_git.ensure_file('README', 'I will conflict with you!!!')
 
         target_repo._local_fetch(self.repo.path, 'master')
         with pytest.raises(RepositoryError):
             target_repo._local_merge(
                 'merge_message', 'user name', '[e-mail]',
                 target_repo._last_fetch_heads())
 
         # Check we are not left in an intermediate merge state
         assert not os.path.exists(
             os.path.join(target_repo.path, '.git', 'MERGE_HEAD'))
 
     def test_local_merge_into_empty_repo(self, tmp_path_factory):
         target_repo = self.get_empty_repo(tmp_path_factory)
 
         # This is required as one cannot do a -ff-only merge in an empty repo.
         target_repo._local_fetch(self.repo.path, 'master')
         with pytest.raises(RepositoryError):
             target_repo._local_merge(
                 'merge_message', 'user name', '[e-mail]',
                 target_repo._last_fetch_heads())
 
     def test_local_merge_in_bare_repo(self):
         with pytest.raises(RepositoryError):
             self.repo._local_merge(
                 'merge_message', 'user name', '[e-mail]', None)
 
     def test_local_push_non_bare(self, tmp_path_factory):
         target_repo = self.get_empty_repo(tmp_path_factory)
 
         pushed_branch = 'pushed_branch'
         self.repo._local_push('master', target_repo.path, pushed_branch)
         # Fix the HEAD of the target repo, or otherwise GitRepository won't
         # report any branches.
         with open(os.path.join(target_repo.path, '.git', 'HEAD'), 'w') as f:
             f.write('ref: refs/heads/%s' % pushed_branch)
 
         target_repo = GitRepository(target_repo.path)
 
         assert (target_repo.branches[pushed_branch] ==
                 self.repo.branches['master'])
 
     def test_local_push_bare(self, tmp_path_factory):
         target_repo = self.get_empty_repo(tmp_path_factory, bare=True)
 
         pushed_branch = 'pushed_branch'
         self.repo._local_push('master', target_repo.path, pushed_branch)
         # Fix the HEAD of the target repo, or otherwise GitRepository won't
         # report any branches.
         with open(os.path.join(target_repo.path, 'HEAD'), 'w') as f:
             f.write('ref: refs/heads/%s' % pushed_branch)
 
         target_repo = GitRepository(target_repo.path)
 
         assert (target_repo.branches[pushed_branch] ==
                 self.repo.branches['master'])
 
     def test_local_push_non_bare_target_branch_is_checked_out(self, tmp_path_factory):
         target_repo = self.get_clone_repo(tmp_path_factory)
 
         pushed_branch = 'pushed_branch'
         # Create a new branch in source repo
         new_branch_commit = target_repo.commit_ids[-3]
         target_repo._checkout(new_branch_commit)
         target_repo._checkout(pushed_branch, create=True)
 
         self.repo._local_push('master', target_repo.path, pushed_branch)
 
         target_repo = GitRepository(target_repo.path)
 
         assert (target_repo.branches[pushed_branch] ==
                 self.repo.branches['master'])
 
     def test_local_push_raises_exception_on_conflict(self, vcsbackend_git):
         target_repo = vcsbackend_git.create_repo(number_of_commits=1)
         with pytest.raises(RepositoryError):
             self.repo._local_push('master', target_repo.path, 'master')
 
     def test_hooks_can_be_enabled_via_env_variable_for_local_push(self, tmp_path_factory):
         target_repo = self.get_empty_repo(tmp_path_factory, bare=True)
 
         with mock.patch.object(self.repo, 'run_git_command') as run_mock:
             self.repo._local_push(
                 'master', target_repo.path, 'master', enable_hooks=True)
         env = run_mock.call_args[1]['extra_env']
         assert 'RC_SKIP_HOOKS' not in env
 
     def _add_failing_hook(self, repo_path, hook_name, bare=False):
         path_components = (
             ['hooks', hook_name] if bare else ['.git', 'hooks', hook_name])
         hook_path = os.path.join(repo_path, *path_components)
         with open(hook_path, 'w') as f:
             script_lines = [
                 '#!%s' % sys.executable,
                 'import os',
                 'import sys',
                 'if os.environ.get("RC_SKIP_HOOKS"):',
                 '    sys.exit(0)',
                 'sys.exit(1)',
             ]
             f.write('\n'.join(script_lines))
         os.chmod(hook_path, 0o755)
 
     def test_local_push_does_not_execute_hook(self, tmp_path_factory):
         target_repo = self.get_empty_repo(tmp_path_factory)
 
         pushed_branch = 'pushed_branch'
         self._add_failing_hook(target_repo.path, 'pre-receive')
         self.repo._local_push('master', target_repo.path, pushed_branch)
         # Fix the HEAD of the target repo, or otherwise GitRepository won't
         # report any branches.
         with open(os.path.join(target_repo.path, '.git', 'HEAD'), 'w') as f:
             f.write('ref: refs/heads/%s' % pushed_branch)
 
         target_repo = GitRepository(target_repo.path)
 
         assert (target_repo.branches[pushed_branch] ==
                 self.repo.branches['master'])
 
     def test_local_push_executes_hook(self, tmp_path_factory):
         target_repo = self.get_empty_repo(tmp_path_factory, bare=True)
         self._add_failing_hook(target_repo.path, 'pre-receive', bare=True)
         with pytest.raises(RepositoryError):
             self.repo._local_push(
                 'master', target_repo.path, 'master', enable_hooks=True)
 
     def test_maybe_prepare_merge_workspace(self):
         workspace = self.repo._maybe_prepare_merge_workspace(
             2, 'pr2', Reference('branch', 'master', 'unused'),
             Reference('branch', 'master', 'unused'))
 
         assert os.path.isdir(workspace)
         workspace_repo = GitRepository(workspace)
         assert workspace_repo.branches == self.repo.branches
 
         # Calling it a second time should also succeed
         workspace = self.repo._maybe_prepare_merge_workspace(
             2, 'pr2', Reference('branch', 'master', 'unused'),
             Reference('branch', 'master', 'unused'))
         assert os.path.isdir(workspace)
 
     def test_maybe_prepare_merge_workspace_different_refs(self):
         workspace = self.repo._maybe_prepare_merge_workspace(
             2, 'pr2', Reference('branch', 'master', 'unused'),
             Reference('branch', 'develop', 'unused'))
 
         assert os.path.isdir(workspace)
         workspace_repo = GitRepository(workspace)
         assert workspace_repo.branches == self.repo.branches
 
         # Calling it a second time should also succeed
         workspace = self.repo._maybe_prepare_merge_workspace(
             2, 'pr2', Reference('branch', 'master', 'unused'),
             Reference('branch', 'develop', 'unused'))
         assert os.path.isdir(workspace)
 
     def test_cleanup_merge_workspace(self):
         workspace = self.repo._maybe_prepare_merge_workspace(
             2, 'pr3', Reference('branch', 'master', 'unused'),
             Reference('branch', 'master', 'unused'))
         self.repo.cleanup_merge_workspace(2, 'pr3')
 
         assert not os.path.exists(workspace)
 
     def test_cleanup_merge_workspace_invalid_workspace_id(self):
         # No assert: because in case of an inexistent workspace this function
         # should still succeed.
         self.repo.cleanup_merge_workspace(1, 'pr4')
 
     def test_set_refs(self):
         test_ref = 'refs/test-refs/abcde'
         test_commit_id = 'ecb86e1f424f2608262b130db174a7dfd25a6623'
 
         self.repo.set_refs(test_ref, test_commit_id)
         stdout, _ = self.repo.run_git_command(['show-ref'])
         assert test_ref in stdout
         assert test_commit_id in stdout
 
     def test_remove_ref(self):
         test_ref = 'refs/test-refs/abcde'
         test_commit_id = 'ecb86e1f424f2608262b130db174a7dfd25a6623'
         self.repo.set_refs(test_ref, test_commit_id)
         stdout, _ = self.repo.run_git_command(['show-ref'])
         assert test_ref in stdout
         assert test_commit_id in stdout
 
         self.repo.remove_ref(test_ref)
         stdout, _ = self.repo.run_git_command(['show-ref'])
         assert test_ref not in stdout
         assert test_commit_id not in stdout
 
 
 class TestGitCommit(object):
 
     @pytest.fixture(autouse=True)
     def prepare(self):
         self.repo = GitRepository(TEST_GIT_REPO)
 
     def test_default_commit(self):
         tip = self.repo.get_commit()
         assert tip == self.repo.get_commit(None)
         assert tip == self.repo.get_commit('tip')
 
     def test_root_node(self):
         tip = self.repo.get_commit()
         assert tip.root is tip.get_node('')
 
     def test_lazy_fetch(self):
         """
         Test if commit's nodes expands and are cached as we walk through
         the commit. This test is somewhat hard to write as order of tests
         is a key here. Written by running command after command in a shell.
         """
         commit_id = '2a13f185e4525f9d4b59882791a2d397b90d5ddc'
         assert commit_id in self.repo.commit_ids
         commit = self.repo.get_commit(commit_id)
         assert len(commit.nodes) == 0
         root = commit.root
         assert len(commit.nodes) == 1
         assert len(root.nodes) == 8
         # accessing root.nodes updates commit.nodes
         assert len(commit.nodes) == 9
 
         docs = root.get_node('docs')
         # we haven't yet accessed anything new as docs dir was already cached
         assert len(commit.nodes) == 9
         assert len(docs.nodes) == 8
         # accessing docs.nodes updates commit.nodes
         assert len(commit.nodes) == 17
 
         assert docs is commit.get_node('docs')
         assert docs is root.nodes[0]
         assert docs is root.dirs[0]
         assert docs is commit.get_node('docs')
 
     def test_nodes_with_commit(self):
         commit_id = '2a13f185e4525f9d4b59882791a2d397b90d5ddc'
         commit = self.repo.get_commit(commit_id)
         root = commit.root
         docs = root.get_node('docs')
         assert docs is commit.get_node('docs')
         api = docs.get_node('api')
         assert api is commit.get_node('docs/api')
         index = api.get_node('index.rst')
         assert index is commit.get_node('docs/api/index.rst')
         assert index is commit.get_node('docs')\
             .get_node('api')\
             .get_node('index.rst')
 
     def test_branch_and_tags(self):
         """
         rev0 = self.repo.commit_ids[0]
         commit0 = self.repo.get_commit(rev0)
         assert commit0.branch == 'master'
         assert commit0.tags == []
 
         rev10 = self.repo.commit_ids[10]
         commit10 = self.repo.get_commit(rev10)
         assert commit10.branch == 'master'
         assert commit10.tags == []
 
         rev44 = self.repo.commit_ids[44]
         commit44 = self.repo.get_commit(rev44)
         assert commit44.branch == 'web-branch'
 
         tip = self.repo.get_commit('tip')
         assert 'tip' in tip.tags
         """
         # Those tests would fail - branches are now going
         # to be changed at main API in order to support git backend
         pass
 
     def test_file_size(self):
         to_check = (
             ('c1214f7e79e02fc37156ff215cd71275450cffc3',
                 'vcs/backends/BaseRepository.py', 502),
             ('d7e0d30fbcae12c90680eb095a4f5f02505ce501',
                 'vcs/backends/hg.py', 854),
             ('6e125e7c890379446e98980d8ed60fba87d0f6d1',
                 'setup.py', 1068),
 
             ('d955cd312c17b02143c04fa1099a352b04368118',
                 'vcs/backends/base.py', 2921),
             ('ca1eb7957a54bce53b12d1a51b13452f95bc7c7e',
                 'vcs/backends/base.py', 3936),
             ('f50f42baeed5af6518ef4b0cb2f1423f3851a941',
                 'vcs/backends/base.py', 6189),
         )
         for commit_id, path, size in to_check:
             node = self.repo.get_commit(commit_id).get_node(path)
             assert node.is_file()
             assert node.size == size
 
     def test_file_history_from_commits(self):
         node = self.repo[10].get_node('setup.py')
         commit_ids = [commit.raw_id for commit in node.history]
         assert ['ff7ca51e58c505fec0dd2491de52c622bb7a806b'] == commit_ids
 
         node = self.repo[20].get_node('setup.py')
         node_ids = [commit.raw_id for commit in node.history]
         assert ['191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e',
                 'ff7ca51e58c505fec0dd2491de52c622bb7a806b'] == node_ids
 
         # special case we check history from commit that has this particular
         # file changed this means we check if it's included as well
         node = self.repo.get_commit('191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e') \
             .get_node('setup.py')
         node_ids = [commit.raw_id for commit in node.history]
         assert ['191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e',
                 'ff7ca51e58c505fec0dd2491de52c622bb7a806b'] == node_ids
 
     def test_file_history(self):
         # we can only check if those commits are present in the history
         # as we cannot update this test every time file is changed
         files = {
             'setup.py': [
                 '54386793436c938cff89326944d4c2702340037d',
                 '51d254f0ecf5df2ce50c0b115741f4cf13985dab',
                 '998ed409c795fec2012b1c0ca054d99888b22090',
                 '5e0eb4c47f56564395f76333f319d26c79e2fb09',
                 '0115510b70c7229dbc5dc49036b32e7d91d23acd',
                 '7cb3fd1b6d8c20ba89e2264f1c8baebc8a52d36e',
                 '2a13f185e4525f9d4b59882791a2d397b90d5ddc',
                 '191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e',
                 'ff7ca51e58c505fec0dd2491de52c622bb7a806b',
             ],
             'vcs/nodes.py': [
                 '33fa3223355104431402a888fa77a4e9956feb3e',
                 'fa014c12c26d10ba682fadb78f2a11c24c8118e1',
                 'e686b958768ee96af8029fe19c6050b1a8dd3b2b',
                 'ab5721ca0a081f26bf43d9051e615af2cc99952f',
                 'c877b68d18e792a66b7f4c529ea02c8f80801542',
                 '4313566d2e417cb382948f8d9d7c765330356054',
                 '6c2303a793671e807d1cfc70134c9ca0767d98c2',
                 '54386793436c938cff89326944d4c2702340037d',
                 '54000345d2e78b03a99d561399e8e548de3f3203',
                 '1c6b3677b37ea064cb4b51714d8f7498f93f4b2b',
                 '2d03ca750a44440fb5ea8b751176d1f36f8e8f46',
                 '2a08b128c206db48c2f0b8f70df060e6db0ae4f8',
                 '30c26513ff1eb8e5ce0e1c6b477ee5dc50e2f34b',
                 'ac71e9503c2ca95542839af0ce7b64011b72ea7c',
                 '12669288fd13adba2a9b7dd5b870cc23ffab92d2',
                 '5a0c84f3e6fe3473e4c8427199d5a6fc71a9b382',
                 '12f2f5e2b38e6ff3fbdb5d722efed9aa72ecb0d5',
                 '5eab1222a7cd4bfcbabc218ca6d04276d4e27378',
                 'f50f42baeed5af6518ef4b0cb2f1423f3851a941',
                 'd7e390a45f6aa96f04f5e7f583ad4f867431aa25',
                 'f15c21f97864b4f071cddfbf2750ec2e23859414',
                 'e906ef056cf539a4e4e5fc8003eaf7cf14dd8ade',
                 'ea2b108b48aa8f8c9c4a941f66c1a03315ca1c3b',
                 '84dec09632a4458f79f50ddbbd155506c460b4f9',
                 '0115510b70c7229dbc5dc49036b32e7d91d23acd',
                 '2a13f185e4525f9d4b59882791a2d397b90d5ddc',
                 '3bf1c5868e570e39569d094f922d33ced2fa3b2b',
                 'b8d04012574729d2c29886e53b1a43ef16dd00a1',
                 '6970b057cffe4aab0a792aa634c89f4bebf01441',
                 'dd80b0f6cf5052f17cc738c2951c4f2070200d7f',
                 'ff7ca51e58c505fec0dd2491de52c622bb7a806b',
             ],
             'vcs/backends/git.py': [
                 '4cf116ad5a457530381135e2f4c453e68a1b0105',
                 '9a751d84d8e9408e736329767387f41b36935153',
                 'cb681fb539c3faaedbcdf5ca71ca413425c18f01',
                 '428f81bb652bcba8d631bce926e8834ff49bdcc6',
                 '180ab15aebf26f98f714d8c68715e0f05fa6e1c7',
                 '2b8e07312a2e89e92b90426ab97f349f4bce2a3a',
                 '50e08c506174d8645a4bb517dd122ac946a0f3bf',
                 '54000345d2e78b03a99d561399e8e548de3f3203',
             ],
         }
         for path, commit_ids in files.items():
             node = self.repo.get_commit(commit_ids[0]).get_node(path)
             node_ids = [commit.raw_id for commit in node.history]
             assert set(commit_ids).issubset(set(node_ids)), (
                 "We assumed that %s is subset of commit_ids for which file %s "
                 "has been changed, and history of that node returned: %s"
                 % (commit_ids, path, node_ids))
 
     def test_file_annotate(self):
         files = {
             'vcs/backends/__init__.py': {
                 'c1214f7e79e02fc37156ff215cd71275450cffc3': {
                     'lines_no': 1,
                     'commits': [
                         'c1214f7e79e02fc37156ff215cd71275450cffc3',
                     ],
                 },
                 '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647': {
                     'lines_no': 21,
                     'commits': [
                         '49d3fd156b6f7db46313fac355dca1a0b94a0017',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                     ],
                 },
                 'e29b67bd158580fc90fc5e9111240b90e6e86064': {
                     'lines_no': 32,
                     'commits': [
                         '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, commit_dict in files.items():
             for commit_id, __ in commit_dict.items():
                 commit = self.repo.get_commit(commit_id)
 
                 l1_1 = [x[1] for x in commit.get_file_annotate(fname)]
                 l1_2 = [x[2]().raw_id for x in commit.get_file_annotate(fname)]
                 assert l1_1 == l1_2
                 l1 = l1_1
                 l2 = files[fname][commit_id]['commits']
                 assert l1 == l2, (
                     "The lists of commit_ids for %s@commit_id %s"
                     "from annotation list should match each other, "
                     "got \n%s \nvs \n%s " % (fname, commit_id, l1, l2))
 
     def test_files_state(self):
         """
         Tests state of FileNodes.
         """
         node = self.repo\
             .get_commit('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_commit('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_commit('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
         # CommitError exception
         commit = self.repo.get_commit(
             'fa6600f6848800641328adbf7811fd2372c02ab2')
         path = 'vcs/backends/BaseRepository.py'
         with pytest.raises(NodeDoesNotExistError):
             commit.get_node(path)
         # but it would be one of ``removed`` (commit's attribute)
         assert path in [rf.path for rf in commit.removed]
 
         commit = self.repo.get_commit(
             '54386793436c938cff89326944d4c2702340037d')
         changed = [
             'setup.py', 'tests/test_nodes.py', 'vcs/backends/hg.py',
             'vcs/nodes.py']
         assert set(changed) == set([f.path for f in commit.changed])
 
     def test_unicode_branch_refs(self):
         unicode_branches = {
             'refs/heads/unicode': '6c0ce52b229aa978889e91b38777f800e85f330b',
             u'refs/heads/uniçö∂e': 'ürl',
         }
         with mock.patch(
             ("rhodecode.lib.vcs.backends.git.repository"
                 ".GitRepository._refs"),
                 unicode_branches):
             branches = self.repo.branches
 
         assert 'unicode' in branches
         assert u'uniçö∂e' in branches
 
     def test_unicode_tag_refs(self):
         unicode_tags = {
             'refs/tags/unicode': '6c0ce52b229aa978889e91b38777f800e85f330b',
             u'refs/tags/uniçö∂e': '6c0ce52b229aa978889e91b38777f800e85f330b',
         }
         with mock.patch(
             ("rhodecode.lib.vcs.backends.git.repository"
                 ".GitRepository._refs"),
                 unicode_tags):
             tags = self.repo.tags
 
         assert 'unicode' in tags
         assert u'uniçö∂e' in tags
 
     def test_commit_message_is_unicode(self):
         for commit in self.repo:
             assert type(commit.message) == unicode
 
     def test_commit_author_is_unicode(self):
         for commit in self.repo:
             assert type(commit.author) == unicode
 
     def test_repo_files_content_is_unicode(self):
         commit = self.repo.get_commit()
         for node in commit.get_node('/'):
             if node.is_file():
                 assert type(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_commit()
         with pytest.raises(VCSError):
             tip.get_node(path)
 
     @pytest.mark.parametrize("author_email, commit_id", [
         ('[e-mail]', 'c1214f7e79e02fc37156ff215cd71275450cffc3'),
         ('[e-mail]',
          'ff7ca51e58c505fec0dd2491de52c622bb7a806b'),
         ('none@none', '8430a588b43b5d6da365400117c89400326e7992'),
     ])
     def test_author_email(self, author_email, commit_id):
         commit = self.repo.get_commit(commit_id)
         assert author_email == commit.author_email
 
     @pytest.mark.parametrize("author, commit_id", [
         ('Marcin Kuzminski', 'c1214f7e79e02fc37156ff215cd71275450cffc3'),
         ('Lukasz Balcerzak', 'ff7ca51e58c505fec0dd2491de52c622bb7a806b'),
         ('marcink', '8430a588b43b5d6da365400117c89400326e7992'),
     ])
     def test_author_username(self, author, commit_id):
         commit = self.repo.get_commit(commit_id)
         assert author == commit.author_name
 
 
 class TestLargeFileRepo(object):
 
     def test_large_file(self, backend_git):
         conf = make_db_config()
         repo = backend_git.create_test_repo('largefiles', conf)
 
         tip = repo.scm_instance().get_commit()
 
         # extract stored LF node into the origin cache
         lfs_store = os.path.join(repo.repo_path, repo.repo_name, 'lfs_store')
 
         oid = '7b331c02e313c7599d5a90212e17e6d3cb729bd2e1c9b873c302a63c95a2f9bf'
         oid_path = os.path.join(lfs_store, oid)
         oid_destination = os.path.join(
             conf.get('vcs_git_lfs', 'store_location'), oid)
         shutil.copy(oid_path, oid_destination)
 
         node = tip.get_node('1MB.zip')
 
         lf_node = node.get_largefile_node()
 
         assert lf_node.is_largefile() is True
         assert lf_node.size == 1024000
         assert lf_node.name == '1MB.zip'
 
 
 @pytest.mark.usefixtures("vcs_repository_support")
 class TestGitSpecificWithRepo(BackendTestMixin):
 
     @classmethod
     def _get_commits(cls):
         return [
             {
                 'message': 'Initial',
                 'author': 'Joe Doe <[e-mail]>',
                 '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 <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 22),
                 'added': [
                     FileNode('foo2', content='foo2'),
                 ],
             },
         ]
 
     def test_paths_slow_traversing(self):
         commit = self.repo.get_commit()
         assert commit.get_node('foobar').get_node('static').get_node('js')\
             .get_node('admin').get_node('base.js').content == 'base'
 
     def test_paths_fast_traversing(self):
         commit = self.repo.get_commit()
-        assert (
-            commit.get_node('foobar/static/js/admin/base.js').content ==
-            'base')
+        assert commit.get_node('foobar/static/js/admin/base.js').content == 'base'
 
     def test_get_diff_runs_git_command_with_hashes(self):
         comm1 = self.repo[0]
         comm2 = self.repo[1]
-        self.repo.run_git_command = mock.Mock(return_value=['', ''])
-        self.repo.get_diff(comm1, comm2)
+
+        with mock.patch.object(self.repo, '_remote') as remote_mock:
+            self.repo.get_diff(comm1, comm2)
 
-        self.repo.run_git_command.assert_called_once_with(
-            ['diff', '-U3', '--full-index', '--binary', '-p', '-M',
-             '--abbrev=40', comm1.raw_id, comm2.raw_id])
+        remote_mock.diff.assert_called_once_with(
+            comm1.raw_id, comm2.raw_id,
+            file_filter=None, opt_ignorews=False, context=3)
 
     def test_get_diff_runs_git_command_with_str_hashes(self):
         comm2 = self.repo[1]
-        self.repo.run_git_command = mock.Mock(return_value=['', ''])
-        self.repo.get_diff(self.repo.EMPTY_COMMIT, comm2)
-        self.repo.run_git_command.assert_called_once_with(
-            ['show', '-U3', '--full-index', '--binary', '-p', '-M',
-             '--abbrev=40', comm2.raw_id])
+        with mock.patch.object(self.repo, '_remote') as remote_mock:
+            self.repo.get_diff(self.repo.EMPTY_COMMIT, comm2)
+        remote_mock.diff.assert_called_once_with(
+            self.repo.EMPTY_COMMIT.raw_id, comm2.raw_id,
+            file_filter=None, opt_ignorews=False, context=3)
 
     def test_get_diff_runs_git_command_with_path_if_its_given(self):
         comm1 = self.repo[0]
         comm2 = self.repo[1]
-        self.repo.run_git_command = mock.Mock(return_value=['', ''])
-        self.repo.get_diff(comm1, comm2, 'foo')
-        self.repo.run_git_command.assert_called_once_with(
-            ['diff', '-U3', '--full-index', '--binary', '-p', '-M',
-             '--abbrev=40', self.repo._lookup_commit(0),
-             comm2.raw_id, '--', 'foo'])
+        with mock.patch.object(self.repo, '_remote') as remote_mock:
+            self.repo.get_diff(comm1, comm2, 'foo')
+        remote_mock.diff.assert_called_once_with(
+            self.repo._lookup_commit(0), comm2.raw_id,
+            file_filter='foo', opt_ignorews=False, context=3)
 
 
 @pytest.mark.usefixtures("vcs_repository_support")
 class TestGitRegression(BackendTestMixin):
 
     @classmethod
     def _get_commits(cls):
         return [
             {
                 'message': 'Initial',
                 'author': 'Joe Doe <[e-mail]>',
                 '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 <[e-mail]>',
                 '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'),
                 ],
             },
         ]
 
     @pytest.mark.parametrize("path, expected_paths", [
         ('bot', [
             'bot/build',
             'bot/templates',
             'bot/__init__.py']),
         ('bot/build', [
             'bot/build/migrations',
             'bot/build/static',
             'bot/build/templates']),
         ('bot/build/static', [
             'bot/build/static/templates']),
         ('bot/build/static/templates', [
             'bot/build/static/templates/f.html',
             'bot/build/static/templates/f1.html']),
         ('bot/build/templates', [
             'bot/build/templates/err.html',
             'bot/build/templates/err2.html']),
         ('bot/templates/', [
             'bot/templates/404.html',
             'bot/templates/500.html']),
     ])
     def test_similar_paths(self, path, expected_paths):
         commit = self.repo.get_commit()
         paths = [n.path for n in commit.get_nodes(path)]
         assert paths == expected_paths
 
 
 class TestDiscoverGitVersion(object):
 
     def test_returns_git_version(self, baseapp):
         version = discover_git_version()
         assert version
 
     def test_returns_empty_string_without_vcsserver(self):
         mock_connection = mock.Mock()
         mock_connection.discover_git_version = mock.Mock(
             side_effect=Exception)
         with mock.patch('rhodecode.lib.vcs.connection.Git', mock_connection):
             version = discover_git_version()
         assert version == ''
 
 
 class TestGetSubmoduleUrl(object):
     def test_submodules_file_found(self):
         commit = GitCommit(repository=mock.Mock(), raw_id='abcdef12', idx=1)
         node = mock.Mock()
         with mock.patch.object(
                 commit, 'get_node', return_value=node) as get_node_mock:
             node.content = (
                 '[submodule "subrepo1"]\n'
                 '\tpath = subrepo1\n'
                 '\turl = https://code.rhodecode.com/dulwich\n'
             )
             result = commit._get_submodule_url('subrepo1')
         get_node_mock.assert_called_once_with('.gitmodules')
         assert result == 'https://code.rhodecode.com/dulwich'
 
     def test_complex_submodule_path(self):
         commit = GitCommit(repository=mock.Mock(), raw_id='abcdef12', idx=1)
         node = mock.Mock()
         with mock.patch.object(
                 commit, 'get_node', return_value=node) as get_node_mock:
             node.content = (
                 '[submodule "complex/subrepo/path"]\n'
                 '\tpath = complex/subrepo/path\n'
                 '\turl = https://code.rhodecode.com/dulwich\n'
             )
             result = commit._get_submodule_url('complex/subrepo/path')
         get_node_mock.assert_called_once_with('.gitmodules')
         assert result == 'https://code.rhodecode.com/dulwich'
 
     def test_submodules_file_not_found(self):
         commit = GitCommit(repository=mock.Mock(), raw_id='abcdef12', idx=1)
         with mock.patch.object(
                 commit, 'get_node', side_effect=NodeDoesNotExistError):
             result = commit._get_submodule_url('complex/subrepo/path')
         assert result is None
 
     def test_path_not_found(self):
         commit = GitCommit(repository=mock.Mock(), raw_id='abcdef12', idx=1)
         node = mock.Mock()
         with mock.patch.object(
                 commit, 'get_node', return_value=node) as get_node_mock:
             node.content = (
                 '[submodule "subrepo1"]\n'
                 '\tpath = subrepo1\n'
                 '\turl = https://code.rhodecode.com/dulwich\n'
             )
             result = commit._get_submodule_url('subrepo2')
         get_node_mock.assert_called_once_with('.gitmodules')
         assert result is None
 
     def test_returns_cached_values(self):
         commit = GitCommit(repository=mock.Mock(), raw_id='abcdef12', idx=1)
         node = mock.Mock()
         with mock.patch.object(
                 commit, 'get_node', return_value=node) as get_node_mock:
             node.content = (
                 '[submodule "subrepo1"]\n'
                 '\tpath = subrepo1\n'
                 '\turl = https://code.rhodecode.com/dulwich\n'
             )
             for _ in range(3):
                 commit._get_submodule_url('subrepo1')
         get_node_mock.assert_called_once_with('.gitmodules')
 
     def test_get_node_returns_a_link(self):
         repository = mock.Mock()
         repository.alias = 'git'
         commit = GitCommit(repository=repository, raw_id='abcdef12', idx=1)
         submodule_url = 'https://code.rhodecode.com/dulwich'
         get_id_patch = mock.patch.object(
             commit, '_get_tree_id_for_path', return_value=(1, 'link'))
         get_submodule_patch = mock.patch.object(
             commit, '_get_submodule_url', return_value=submodule_url)
 
         with get_id_patch, get_submodule_patch as submodule_mock:
             node = commit.get_node('/abcde')
 
         submodule_mock.assert_called_once_with('/abcde')
         assert type(node) == SubModuleNode
         assert node.url == submodule_url
 
     def test_get_nodes_returns_links(self):
         repository = mock.MagicMock()
         repository.alias = 'git'
         repository._remote.tree_items.return_value = [
             ('subrepo', 'stat', 1, 'link')
         ]
         commit = GitCommit(repository=repository, raw_id='abcdef12', idx=1)
         submodule_url = 'https://code.rhodecode.com/dulwich'
         get_id_patch = mock.patch.object(
             commit, '_get_tree_id_for_path', return_value=(1, 'tree'))
         get_submodule_patch = mock.patch.object(
             commit, '_get_submodule_url', return_value=submodule_url)
 
         with get_id_patch, get_submodule_patch as submodule_mock:
             nodes = commit.get_nodes('/abcde')
 
         submodule_mock.assert_called_once_with('/abcde/subrepo')
         assert len(nodes) == 1
         assert type(nodes[0]) == SubModuleNode
         assert nodes[0].url == submodule_url

rhodecode/tests/vcs/test_hg.py

@@ -1,1188 +1,1188 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 
 import mock
 import pytest
 
 from rhodecode.lib.utils import make_db_config
 from rhodecode.lib.vcs import backends
 from rhodecode.lib.vcs.backends.base import (
     Reference, MergeResponse, MergeFailureReason)
 from rhodecode.lib.vcs.backends.hg import MercurialRepository, MercurialCommit
 from rhodecode.lib.vcs.exceptions import (
     RepositoryError, VCSError, NodeDoesNotExistError, CommitDoesNotExistError)
 from rhodecode.lib.vcs.nodes import FileNode, NodeKind, NodeState
 from rhodecode.tests import TEST_HG_REPO, TEST_HG_REPO_CLONE, repo_id_generator
 
 
 pytestmark = pytest.mark.backends("hg")
 
 
 def repo_path_generator():
     """
     Return a different path to be used for cloning repos.
     """
     i = 0
     while True:
         i += 1
         yield '%s-%d' % (TEST_HG_REPO_CLONE, i)
 
 REPO_PATH_GENERATOR = repo_path_generator()
 
 
 @pytest.fixture(scope='class', autouse=True)
 def repo(request, baseapp):
     repo = MercurialRepository(TEST_HG_REPO)
     if request.cls:
         request.cls.repo = repo
     return repo
 
 
-class TestMercurialRepository:
+class TestMercurialRepository(object):
 
     # pylint: disable=protected-access
 
     def get_clone_repo(self):
         """
         Return a clone of the base repo.
         """
         clone_path = next(REPO_PATH_GENERATOR)
         repo_clone = MercurialRepository(
             clone_path, create=True, src_url=self.repo.path)
 
         return repo_clone
 
     def get_empty_repo(self):
         """
         Return an empty repo.
         """
         return MercurialRepository(next(REPO_PATH_GENERATOR), create=True)
 
     def test_wrong_repo_path(self):
         wrong_repo_path = '/tmp/errorrepo_hg'
         with pytest.raises(RepositoryError):
             MercurialRepository(wrong_repo_path)
 
     def test_unicode_path_repo(self):
         with pytest.raises(VCSError):
             MercurialRepository(u'iShouldFail')
 
     def test_unicode_commit_id(self):
         with pytest.raises(CommitDoesNotExistError):
             self.repo.get_commit(u'unicode-commit-id')
         with pytest.raises(CommitDoesNotExistError):
             self.repo.get_commit(u'unícøde-spéçial-chäråcter-commit-id')
 
     def test_unicode_bookmark(self):
         self.repo.bookmark(u'unicode-bookmark')
         self.repo.bookmark(u'unícøde-spéçial-chäråcter-bookmark')
 
     def test_unicode_branch(self):
         with pytest.raises(KeyError):
             self.repo.branches[u'unicode-branch']
         with pytest.raises(KeyError):
             self.repo.branches[u'unícøde-spéçial-chäråcter-branch']
 
     def test_repo_clone(self):
         if os.path.exists(TEST_HG_REPO_CLONE):
             self.fail(
                 'Cannot test mercurial clone repo as location %s already '
                 'exists. You should manually remove it first.'
                 % TEST_HG_REPO_CLONE)
 
         repo = MercurialRepository(TEST_HG_REPO)
         repo_clone = MercurialRepository(TEST_HG_REPO_CLONE,
                                          src_url=TEST_HG_REPO)
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
         # Checking hashes of commits should be enough
         for commit in repo.get_commits():
             raw_id = commit.raw_id
             assert raw_id == repo_clone.get_commit(raw_id).raw_id
 
     def test_repo_clone_with_update(self):
         repo = MercurialRepository(TEST_HG_REPO)
         repo_clone = MercurialRepository(
             TEST_HG_REPO_CLONE + '_w_update',
             src_url=TEST_HG_REPO, do_workspace_checkout=True)
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
 
         # check if current workdir was updated
         assert os.path.isfile(
             os.path.join(TEST_HG_REPO_CLONE + '_w_update', 'MANIFEST.in'))
 
     def test_repo_clone_without_update(self):
         repo = MercurialRepository(TEST_HG_REPO)
         repo_clone = MercurialRepository(
             TEST_HG_REPO_CLONE + '_wo_update',
             src_url=TEST_HG_REPO, do_workspace_checkout=False)
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
         assert not os.path.isfile(
             os.path.join(TEST_HG_REPO_CLONE + '_wo_update', 'MANIFEST.in'))
 
     def test_commit_ids(self):
         # there are 21 commits at bitbucket now
         # so we can assume they would be available from now on
         subset = set([
             'b986218ba1c9b0d6a259fac9b050b1724ed8e545',
             '3d8f361e72ab303da48d799ff1ac40d5ac37c67e',
             '6cba7170863a2411822803fa77a0a264f1310b35',
             '56349e29c2af3ac913b28bde9a2c6154436e615b',
             '2dda4e345facb0ccff1a191052dd1606dba6781d',
             '6fff84722075f1607a30f436523403845f84cd9e',
             '7d4bc8ec6be56c0f10425afb40b6fc315a4c25e7',
             '3803844fdbd3b711175fc3da9bdacfcd6d29a6fb',
             'dc5d2c0661b61928834a785d3e64a3f80d3aad9c',
             'be90031137367893f1c406e0a8683010fd115b79',
             'db8e58be770518cbb2b1cdfa69146e47cd481481',
             '84478366594b424af694a6c784cb991a16b87c21',
             '17f8e105dddb9f339600389c6dc7175d395a535c',
             '20a662e756499bde3095ffc9bc0643d1def2d0eb',
             '2e319b85e70a707bba0beff866d9f9de032aa4f9',
             '786facd2c61deb9cf91e9534735124fb8fc11842',
             '94593d2128d38210a2fcd1aabff6dda0d6d9edf8',
             'aa6a0de05b7612707db567078e130a6cd114a9a7',
             'eada5a770da98ab0dd7325e29d00e0714f228d09'
         ])
         assert subset.issubset(set(self.repo.commit_ids))
 
         # check if we have the proper order of commits
         org = [
             'b986218ba1c9b0d6a259fac9b050b1724ed8e545',
             '3d8f361e72ab303da48d799ff1ac40d5ac37c67e',
             '6cba7170863a2411822803fa77a0a264f1310b35',
             '56349e29c2af3ac913b28bde9a2c6154436e615b',
             '2dda4e345facb0ccff1a191052dd1606dba6781d',
             '6fff84722075f1607a30f436523403845f84cd9e',
             '7d4bc8ec6be56c0f10425afb40b6fc315a4c25e7',
             '3803844fdbd3b711175fc3da9bdacfcd6d29a6fb',
             'dc5d2c0661b61928834a785d3e64a3f80d3aad9c',
             'be90031137367893f1c406e0a8683010fd115b79',
             'db8e58be770518cbb2b1cdfa69146e47cd481481',
             '84478366594b424af694a6c784cb991a16b87c21',
             '17f8e105dddb9f339600389c6dc7175d395a535c',
             '20a662e756499bde3095ffc9bc0643d1def2d0eb',
             '2e319b85e70a707bba0beff866d9f9de032aa4f9',
             '786facd2c61deb9cf91e9534735124fb8fc11842',
             '94593d2128d38210a2fcd1aabff6dda0d6d9edf8',
             'aa6a0de05b7612707db567078e130a6cd114a9a7',
             'eada5a770da98ab0dd7325e29d00e0714f228d09',
             '2c1885c735575ca478bf9e17b0029dca68824458',
             'd9bcd465040bf869799b09ad732c04e0eea99fe9',
             '469e9c847fe1f6f7a697b8b25b4bc5b48780c1a7',
             '4fb8326d78e5120da2c7468dcf7098997be385da',
             '62b4a097164940bd66030c4db51687f3ec035eed',
             '536c1a19428381cfea92ac44985304f6a8049569',
             '965e8ab3c44b070cdaa5bf727ddef0ada980ecc4',
             '9bb326a04ae5d98d437dece54be04f830cf1edd9',
             'f8940bcb890a98c4702319fbe36db75ea309b475',
             'ff5ab059786ebc7411e559a2cc309dfae3625a3b',
             '6b6ad5f82ad5bb6190037671bd254bd4e1f4bf08',
             'ee87846a61c12153b51543bf860e1026c6d3dcba',
         ]
         assert org == self.repo.commit_ids[:31]
 
     def test_iter_slice(self):
         sliced = list(self.repo[:10])
         itered = list(self.repo)[:10]
         assert sliced == itered
 
     def test_slicing(self):
         # 4 1 5 10 95
         for sfrom, sto, size in [(0, 4, 4), (1, 2, 1), (10, 15, 5),
                                  (10, 20, 10), (5, 100, 95)]:
             indexes = list(self.repo[sfrom:sto])
             assert len(indexes) == size
             assert indexes[0] == self.repo.get_commit(commit_idx=sfrom)
             assert indexes[-1] == self.repo.get_commit(commit_idx=sto - 1)
 
     def test_branches(self):
         # TODO: Need more tests here
 
         # active branches
         assert 'default' in self.repo.branches
         assert 'stable' in self.repo.branches
 
         # closed
         assert 'git' in self.repo._get_branches(closed=True)
         assert 'web' in self.repo._get_branches(closed=True)
 
         for name, id in self.repo.branches.items():
             assert isinstance(self.repo.get_commit(id), MercurialCommit)
 
     def test_tip_in_tags(self):
         # tip is always a tag
         assert 'tip' in self.repo.tags
 
     def test_tip_commit_in_tags(self):
         tip = self.repo.get_commit()
         assert self.repo.tags['tip'] == tip.raw_id
 
     def test_initial_commit(self):
         init_commit = self.repo.get_commit(commit_idx=0)
         init_author = init_commit.author
 
         assert init_commit.message == 'initial import'
         assert init_author == 'Marcin Kuzminski <[e-mail]>'
         assert init_author == init_commit.committer
         assert sorted(init_commit._file_paths) == sorted([
             'vcs/__init__.py',
             'vcs/backends/BaseRepository.py',
             'vcs/backends/__init__.py',
         ])
         assert sorted(init_commit._dir_paths) == sorted(
             ['', 'vcs', 'vcs/backends'])
 
         assert init_commit._dir_paths + init_commit._file_paths == \
             init_commit._paths
 
         with pytest.raises(NodeDoesNotExistError):
             init_commit.get_node(path='foobar')
 
         node = init_commit.get_node('vcs/')
         assert hasattr(node, 'kind')
         assert node.kind == NodeKind.DIR
 
         node = init_commit.get_node('vcs')
         assert hasattr(node, 'kind')
         assert node.kind == NodeKind.DIR
 
         node = init_commit.get_node('vcs/__init__.py')
         assert hasattr(node, 'kind')
         assert node.kind == NodeKind.FILE
 
     def test_not_existing_commit(self):
         # rawid
         with pytest.raises(RepositoryError):
             self.repo.get_commit('abcd' * 10)
         # shortid
         with pytest.raises(RepositoryError):
             self.repo.get_commit('erro' * 4)
         # numeric
         with pytest.raises(RepositoryError):
             self.repo.get_commit(commit_idx=self.repo.count() + 1)
 
         # Small chance we ever get to this one
         idx = pow(2, 30)
         with pytest.raises(RepositoryError):
             self.repo.get_commit(commit_idx=idx)
 
     def test_commit10(self):
         commit10 = self.repo.get_commit(commit_idx=10)
         README = """===
 VCS
 ===
 
 Various Version Control System management abstraction layer for Python.
 
 Introduction
 ------------
 
 TODO: To be written...
 
 """
         node = commit10.get_node('README.rst')
         assert node.kind == NodeKind.FILE
         assert node.content == README
 
     def test_local_clone(self):
         clone_path = next(REPO_PATH_GENERATOR)
         self.repo._local_clone(clone_path)
         repo_clone = MercurialRepository(clone_path)
 
         assert self.repo.commit_ids == repo_clone.commit_ids
 
     def test_local_clone_fails_if_target_exists(self):
         with pytest.raises(RepositoryError):
             self.repo._local_clone(self.repo.path)
 
     def test_update(self):
         repo_clone = self.get_clone_repo()
         branches = repo_clone.branches
 
         repo_clone._update('default')
         assert branches['default'] == repo_clone._identify()
         repo_clone._update('stable')
         assert branches['stable'] == repo_clone._identify()
 
     def test_local_pull_branch(self):
         target_repo = self.get_empty_repo()
         source_repo = self.get_clone_repo()
 
         default = Reference(
             'branch', 'default', source_repo.branches['default'])
         target_repo._local_pull(source_repo.path, default)
         target_repo = MercurialRepository(target_repo.path)
         assert (target_repo.branches['default'] ==
                 source_repo.branches['default'])
 
         stable = Reference('branch', 'stable', source_repo.branches['stable'])
         target_repo._local_pull(source_repo.path, stable)
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.branches['stable'] == source_repo.branches['stable']
 
     def test_local_pull_bookmark(self):
         target_repo = self.get_empty_repo()
         source_repo = self.get_clone_repo()
 
         commits = list(source_repo.get_commits(branch_name='default'))
         foo1_id = commits[-5].raw_id
         foo1 = Reference('book', 'foo1', foo1_id)
         source_repo._update(foo1_id)
         source_repo.bookmark('foo1')
 
         foo2_id = commits[-3].raw_id
         foo2 = Reference('book', 'foo2', foo2_id)
         source_repo._update(foo2_id)
         source_repo.bookmark('foo2')
 
         target_repo._local_pull(source_repo.path, foo1)
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.branches['default'] == commits[-5].raw_id
 
         target_repo._local_pull(source_repo.path, foo2)
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.branches['default'] == commits[-3].raw_id
 
     def test_local_pull_commit(self):
         target_repo = self.get_empty_repo()
         source_repo = self.get_clone_repo()
 
         commits = list(source_repo.get_commits(branch_name='default'))
         commit_id = commits[-5].raw_id
         commit = Reference('rev', commit_id, commit_id)
         target_repo._local_pull(source_repo.path, commit)
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.branches['default'] == commit_id
 
         commit_id = commits[-3].raw_id
         commit = Reference('rev', commit_id, commit_id)
         target_repo._local_pull(source_repo.path, commit)
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.branches['default'] == commit_id
 
     def test_local_pull_from_same_repo(self):
         reference = Reference('branch', 'default', None)
         with pytest.raises(ValueError):
             self.repo._local_pull(self.repo.path, reference)
 
     def test_validate_pull_reference_raises_on_missing_reference(
             self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         reference = Reference(
             'book', 'invalid_reference', 'a' * 40)
 
         with pytest.raises(CommitDoesNotExistError):
             target_repo._validate_pull_reference(reference)
 
     def test_heads(self):
         assert set(self.repo._heads()) == set(self.repo.branches.values())
 
     def test_ancestor(self):
         commits = [
             c.raw_id for c in self.repo.get_commits(branch_name='default')]
         assert self.repo._ancestor(commits[-3], commits[-5]) == commits[-5]
         assert self.repo._ancestor(commits[-5], commits[-3]) == commits[-5]
 
     def test_local_push(self):
         target_repo = self.get_empty_repo()
 
         revisions = list(self.repo.get_commits(branch_name='default'))
         revision = revisions[-5].raw_id
         self.repo._local_push(revision, target_repo.path)
 
         target_repo = MercurialRepository(target_repo.path)
 
         assert target_repo.branches['default'] == revision
 
     def test_hooks_can_be_enabled_for_local_push(self):
         revision = 'deadbeef'
         repo_path = 'test_group/test_repo'
         with mock.patch.object(self.repo, '_remote') as remote_mock:
             self.repo._local_push(revision, repo_path, enable_hooks=True)
         remote_mock.push.assert_called_once_with(
             [revision], repo_path, hooks=True, push_branches=False)
 
     def test_local_merge(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         vcsbackend_hg.add_file(target_repo, 'README_MERGE1', 'Version 1')
         target_repo = MercurialRepository(target_repo.path)
         target_rev = target_repo.branches['default']
         target_ref = Reference(
             type='branch', name='default', commit_id=target_rev)
         vcsbackend_hg.add_file(source_repo, 'README_MERGE2', 'Version 2')
         source_repo = MercurialRepository(source_repo.path)
         source_rev = source_repo.branches['default']
         source_ref = Reference(
             type='branch', name='default', commit_id=source_rev)
 
         target_repo._local_pull(source_repo.path, source_ref)
 
         merge_message = 'Merge message\n\nDescription:...'
         user_name = 'Albert Einstein'
         user_email = '[e-mail]'
         merge_commit_id, needs_push = target_repo._local_merge(
             target_ref, merge_message, user_name, user_email, source_ref)
         assert needs_push
 
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.commit_ids[-3] == target_rev
         assert target_repo.commit_ids[-2] == source_rev
         last_commit = target_repo.get_commit(merge_commit_id)
         assert last_commit.message.strip() == merge_message
         assert last_commit.author == '%s <%s>' % (user_name, user_email)
 
         assert not os.path.exists(
             os.path.join(target_repo.path, '.hg', 'merge', 'state'))
 
     def test_local_merge_source_is_fast_forward(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         target_rev = target_repo.branches['default']
         target_ref = Reference(
             type='branch', name='default', commit_id=target_rev)
         vcsbackend_hg.add_file(source_repo, 'README_MERGE2', 'Version 2')
         source_repo = MercurialRepository(source_repo.path)
         source_rev = source_repo.branches['default']
         source_ref = Reference(
             type='branch', name='default', commit_id=source_rev)
 
         target_repo._local_pull(source_repo.path, source_ref)
 
         merge_message = 'Merge message\n\nDescription:...'
         user_name = 'Albert Einstein'
         user_email = '[e-mail]'
         merge_commit_id, needs_push = target_repo._local_merge(
             target_ref, merge_message, user_name, user_email, source_ref)
         assert merge_commit_id == source_rev
         assert needs_push
 
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.commit_ids[-2] == target_rev
         assert target_repo.commit_ids[-1] == source_rev
 
         assert not os.path.exists(
             os.path.join(target_repo.path, '.hg', 'merge', 'state'))
 
     def test_local_merge_source_is_integrated(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         target_rev = target_repo.branches['default']
         target_ref = Reference(
             type='branch', name='default', commit_id=target_rev)
 
         merge_message = 'Merge message\n\nDescription:...'
         user_name = 'Albert Einstein'
         user_email = '[e-mail]'
         merge_commit_id, needs_push = target_repo._local_merge(
             target_ref, merge_message, user_name, user_email, target_ref)
         assert merge_commit_id == target_rev
         assert not needs_push
 
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.commit_ids[-1] == target_rev
 
         assert not os.path.exists(
             os.path.join(target_repo.path, '.hg', 'merge', 'state'))
 
     def test_local_merge_raises_exception_on_conflict(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         vcsbackend_hg.add_file(target_repo, 'README_MERGE', 'Version 1')
         target_repo = MercurialRepository(target_repo.path)
         target_rev = target_repo.branches['default']
         target_ref = Reference(
             type='branch', name='default', commit_id=target_rev)
         vcsbackend_hg.add_file(source_repo, 'README_MERGE', 'Version 2')
         source_repo = MercurialRepository(source_repo.path)
         source_rev = source_repo.branches['default']
         source_ref = Reference(
             type='branch', name='default', commit_id=source_rev)
 
         target_repo._local_pull(source_repo.path, source_ref)
         with pytest.raises(RepositoryError):
             target_repo._local_merge(
                 target_ref, 'merge_message', 'user name', '[e-mail]',
                 source_ref)
 
         # Check we are not left in an intermediate merge state
         assert not os.path.exists(
             os.path.join(target_repo.path, '.hg', 'merge', 'state'))
 
     def test_local_merge_of_two_branches_of_the_same_repo(self, backend_hg):
         commits = [
             {'message': 'a'},
             {'message': 'b', 'branch': 'b'},
         ]
         repo = backend_hg.create_repo(commits)
         commit_ids = backend_hg.commit_ids
         target_ref = Reference(
             type='branch', name='default', commit_id=commit_ids['a'])
         source_ref = Reference(
             type='branch', name='b', commit_id=commit_ids['b'])
         merge_message = 'Merge message\n\nDescription:...'
         user_name = 'Albert Einstein'
         user_email = '[e-mail]'
         vcs_repo = repo.scm_instance()
         merge_commit_id, needs_push = vcs_repo._local_merge(
             target_ref, merge_message, user_name, user_email, source_ref)
         assert merge_commit_id != source_ref.commit_id
         assert needs_push is True
         commit = vcs_repo.get_commit(merge_commit_id)
         assert commit.merge is True
         assert commit.message == merge_message
 
     def test_maybe_prepare_merge_workspace(self):
         workspace = self.repo._maybe_prepare_merge_workspace(
             1, 'pr2', 'unused', 'unused2')
 
         assert os.path.isdir(workspace)
         workspace_repo = MercurialRepository(workspace)
         assert workspace_repo.branches == self.repo.branches
 
         # Calling it a second time should also succeed
         workspace = self.repo._maybe_prepare_merge_workspace(
             1, 'pr2', 'unused', 'unused2')
         assert os.path.isdir(workspace)
 
     def test_cleanup_merge_workspace(self):
         workspace = self.repo._maybe_prepare_merge_workspace(
             1, 'pr3', 'unused', 'unused2')
 
         assert os.path.isdir(workspace)
         self.repo.cleanup_merge_workspace(1, 'pr3')
 
         assert not os.path.exists(workspace)
 
     def test_cleanup_merge_workspace_invalid_workspace_id(self):
         # No assert: because in case of an inexistent workspace this function
         # should still succeed.
         self.repo.cleanup_merge_workspace(1, 'pr4')
 
     def test_merge_target_is_bookmark(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         vcsbackend_hg.add_file(target_repo, 'README_MERGE1', 'Version 1')
         vcsbackend_hg.add_file(source_repo, 'README_MERGE2', 'Version 2')
         imc = source_repo.in_memory_commit
         imc.add(FileNode('file_x', content=source_repo.name))
         imc.commit(
             message=u'Automatic commit from repo merge test',
             author=u'Automatic <[e-mail]>')
         target_commit = target_repo.get_commit()
         source_commit = source_repo.get_commit()
         default_branch = target_repo.DEFAULT_BRANCH_NAME
         bookmark_name = 'bookmark'
         target_repo._update(default_branch)
         target_repo.bookmark(bookmark_name)
         target_ref = Reference('book', bookmark_name, target_commit.raw_id)
         source_ref = Reference('branch', default_branch, source_commit.raw_id)
         workspace_id = 'test-merge'
         repo_id = repo_id_generator(target_repo.path)
         merge_response = target_repo.merge(
             repo_id, workspace_id, target_ref, source_repo, source_ref,
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False)
         expected_merge_response = MergeResponse(
             True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
         target_repo = backends.get_backend(vcsbackend_hg.alias)(
             target_repo.path)
         target_commits = list(target_repo.get_commits())
         commit_ids = [c.raw_id for c in target_commits[:-1]]
         assert source_ref.commit_id in commit_ids
         assert target_ref.commit_id in commit_ids
 
         merge_commit = target_commits[-1]
         assert merge_commit.raw_id == merge_response.merge_ref.commit_id
         assert merge_commit.message.strip() == 'merge message 1'
         assert merge_commit.author == 'test user <[e-mail]>'
 
         # Check the bookmark was updated in the target repo
         assert (
             target_repo.bookmarks[bookmark_name] ==
             merge_response.merge_ref.commit_id)
 
     def test_merge_source_is_bookmark(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         imc = source_repo.in_memory_commit
         imc.add(FileNode('file_x', content=source_repo.name))
         imc.commit(
             message=u'Automatic commit from repo merge test',
             author=u'Automatic <[e-mail]>')
         target_commit = target_repo.get_commit()
         source_commit = source_repo.get_commit()
         default_branch = target_repo.DEFAULT_BRANCH_NAME
         bookmark_name = 'bookmark'
         target_ref = Reference('branch', default_branch, target_commit.raw_id)
         source_repo._update(default_branch)
         source_repo.bookmark(bookmark_name)
         source_ref = Reference('book', bookmark_name, source_commit.raw_id)
         workspace_id = 'test-merge'
         repo_id = repo_id_generator(target_repo.path)
         merge_response = target_repo.merge(
             repo_id, workspace_id, target_ref, source_repo, source_ref,
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False)
         expected_merge_response = MergeResponse(
             True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
         target_repo = backends.get_backend(vcsbackend_hg.alias)(
             target_repo.path)
         target_commits = list(target_repo.get_commits())
         commit_ids = [c.raw_id for c in target_commits]
         assert source_ref.commit_id == commit_ids[-1]
         assert target_ref.commit_id == commit_ids[-2]
 
     def test_merge_target_has_multiple_heads(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=2)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         vcsbackend_hg.add_file(target_repo, 'README_MERGE1', 'Version 1')
         vcsbackend_hg.add_file(source_repo, 'README_MERGE2', 'Version 2')
 
         # add an extra head to the target repo
         imc = target_repo.in_memory_commit
         imc.add(FileNode('file_x', content='foo'))
         commits = list(target_repo.get_commits())
         imc.commit(
             message=u'Automatic commit from repo merge test',
             author=u'Automatic <[e-mail]>', parents=commits[0:1])
 
         target_commit = target_repo.get_commit()
         source_commit = source_repo.get_commit()
         default_branch = target_repo.DEFAULT_BRANCH_NAME
         target_repo._update(default_branch)
 
         target_ref = Reference('branch', default_branch, target_commit.raw_id)
         source_ref = Reference('branch', default_branch, source_commit.raw_id)
         workspace_id = 'test-merge'
 
         assert len(target_repo._heads(branch='default')) == 2
         heads = target_repo._heads(branch='default')
         expected_merge_response = MergeResponse(
             False, False, None,
             MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS,
             metadata={'heads': heads})
         repo_id = repo_id_generator(target_repo.path)
         merge_response = target_repo.merge(
             repo_id, workspace_id, target_ref, source_repo, source_ref,
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False)
         assert merge_response == expected_merge_response
 
     def test_merge_rebase_source_is_updated_bookmark(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         vcsbackend_hg.add_file(target_repo, 'README_MERGE1', 'Version 1')
         vcsbackend_hg.add_file(source_repo, 'README_MERGE2', 'Version 2')
         imc = source_repo.in_memory_commit
         imc.add(FileNode('file_x', content=source_repo.name))
         imc.commit(
             message=u'Automatic commit from repo merge test',
             author=u'Automatic <[e-mail]>')
         target_commit = target_repo.get_commit()
         source_commit = source_repo.get_commit()
 
         vcsbackend_hg.add_file(source_repo, 'LICENSE', 'LICENSE Info')
 
         default_branch = target_repo.DEFAULT_BRANCH_NAME
         bookmark_name = 'bookmark'
         source_repo._update(default_branch)
         source_repo.bookmark(bookmark_name)
 
         target_ref = Reference('branch', default_branch, target_commit.raw_id)
         source_ref = Reference('book', bookmark_name, source_commit.raw_id)
         repo_id = repo_id_generator(target_repo.path)
         workspace_id = 'test-merge'
 
         merge_response = target_repo.merge(
             repo_id, workspace_id, target_ref, source_repo, source_ref,
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False, use_rebase=True)
 
         expected_merge_response = MergeResponse(
             True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
         target_repo = backends.get_backend(vcsbackend_hg.alias)(
             target_repo.path)
         last_commit = target_repo.get_commit()
         assert last_commit.message == source_commit.message
         assert last_commit.author == source_commit.author
         # This checks that we effectively did a rebase
         assert last_commit.raw_id != source_commit.raw_id
 
         # Check the target has only 4 commits: 2 were already in target and
         # only two should have been added
         assert len(target_repo.commit_ids) == 2 + 2
 
 
 class TestGetShadowInstance(object):
 
     @pytest.fixture
     def repo(self, vcsbackend_hg, monkeypatch):
         repo = vcsbackend_hg.repo
         monkeypatch.setattr(repo, 'config', mock.Mock())
         monkeypatch.setattr('rhodecode.lib.vcs.connection.Hg', mock.Mock())
         return repo
 
     def test_passes_config(self, repo):
         shadow = repo.get_shadow_instance(repo.path)
         assert shadow.config == repo.config.copy()
 
     def test_disables_hooks(self, repo):
         shadow = repo.get_shadow_instance(repo.path)
         shadow.config.clear_section.assert_called_once_with('hooks')
 
     def test_allows_to_keep_hooks(self, repo):
         shadow = repo.get_shadow_instance(repo.path, enable_hooks=True)
         assert not shadow.config.clear_section.called
 
 
 class TestMercurialCommit(object):
 
     def _test_equality(self, commit):
         idx = commit.idx
         assert commit == self.repo.get_commit(commit_idx=idx)
 
     def test_equality(self):
         indexes = [0, 10, 20]
         commits = [self.repo.get_commit(commit_idx=idx) for idx in indexes]
         for commit in commits:
             self._test_equality(commit)
 
     def test_default_commit(self):
         tip = self.repo.get_commit('tip')
         assert tip == self.repo.get_commit()
         assert tip == self.repo.get_commit(commit_id=None)
         assert tip == self.repo.get_commit(commit_idx=None)
         assert tip == list(self.repo[-1:])[0]
 
     def test_root_node(self):
         tip = self.repo.get_commit('tip')
         assert tip.root is tip.get_node('')
 
     def test_lazy_fetch(self):
         """
         Test if commit's nodes expands and are cached as we walk through
         the commit. This test is somewhat hard to write as order of tests
         is a key here. Written by running command after command in a shell.
         """
         commit = self.repo.get_commit(commit_idx=45)
         assert len(commit.nodes) == 0
         root = commit.root
         assert len(commit.nodes) == 1
         assert len(root.nodes) == 8
         # accessing root.nodes updates commit.nodes
         assert len(commit.nodes) == 9
 
         docs = root.get_node('docs')
         # we haven't yet accessed anything new as docs dir was already cached
         assert len(commit.nodes) == 9
         assert len(docs.nodes) == 8
         # accessing docs.nodes updates commit.nodes
         assert len(commit.nodes) == 17
 
         assert docs is commit.get_node('docs')
         assert docs is root.nodes[0]
         assert docs is root.dirs[0]
         assert docs is commit.get_node('docs')
 
     def test_nodes_with_commit(self):
         commit = self.repo.get_commit(commit_idx=45)
         root = commit.root
         docs = root.get_node('docs')
         assert docs is commit.get_node('docs')
         api = docs.get_node('api')
         assert api is commit.get_node('docs/api')
         index = api.get_node('index.rst')
         assert index is commit.get_node('docs/api/index.rst')
         assert index is commit.get_node(
             'docs').get_node('api').get_node('index.rst')
 
     def test_branch_and_tags(self):
         commit0 = self.repo.get_commit(commit_idx=0)
         assert commit0.branch == 'default'
         assert commit0.tags == []
 
         commit10 = self.repo.get_commit(commit_idx=10)
         assert commit10.branch == 'default'
         assert commit10.tags == []
 
         commit44 = self.repo.get_commit(commit_idx=44)
         assert commit44.branch == 'web'
 
         tip = self.repo.get_commit('tip')
         assert 'tip' in tip.tags
 
     def test_bookmarks(self):
         commit0 = self.repo.get_commit(commit_idx=0)
         assert commit0.bookmarks == []
 
     def _test_file_size(self, idx, path, size):
         node = self.repo.get_commit(commit_idx=idx).get_node(path)
         assert node.is_file()
         assert node.size == size
 
     def test_file_size(self):
         to_check = (
             (10, 'setup.py', 1068),
             (20, 'setup.py', 1106),
             (60, 'setup.py', 1074),
 
             (10, 'vcs/backends/base.py', 2921),
             (20, 'vcs/backends/base.py', 3936),
             (60, 'vcs/backends/base.py', 6189),
         )
         for idx, path, size in to_check:
             self._test_file_size(idx, path, size)
 
     def test_file_history_from_commits(self):
         node = self.repo[10].get_node('setup.py')
         commit_ids = [commit.raw_id for commit in node.history]
         assert ['3803844fdbd3b711175fc3da9bdacfcd6d29a6fb'] == commit_ids
 
         node = self.repo[20].get_node('setup.py')
         node_ids = [commit.raw_id for commit in node.history]
         assert ['eada5a770da98ab0dd7325e29d00e0714f228d09',
                 '3803844fdbd3b711175fc3da9bdacfcd6d29a6fb'] == node_ids
 
         # special case we check history from commit that has this particular
         # file changed this means we check if it's included as well
         node = self.repo.get_commit('eada5a770da98ab0dd7325e29d00e0714f228d09')\
             .get_node('setup.py')
         node_ids = [commit.raw_id for commit in node.history]
         assert ['eada5a770da98ab0dd7325e29d00e0714f228d09',
                 '3803844fdbd3b711175fc3da9bdacfcd6d29a6fb'] == node_ids
 
     def test_file_history(self):
         # we can only check if those commits are present in the history
         # as we cannot update this test every time file is changed
         files = {
             'setup.py': [7, 18, 45, 46, 47, 69, 77],
             'vcs/nodes.py': [
                 7, 8, 24, 26, 30, 45, 47, 49, 56, 57, 58, 59, 60, 61, 73, 76],
             'vcs/backends/hg.py': [
                 4, 5, 6, 11, 12, 13, 14, 15, 16, 21, 22, 23, 26, 27, 28, 30,
                 31, 33, 35, 36, 37, 38, 39, 40, 41, 44, 45, 47, 48, 49, 53, 54,
                 55, 58, 60, 61, 67, 68, 69, 70, 73, 77, 78, 79, 82],
         }
         for path, indexes in files.items():
             tip = self.repo.get_commit(commit_idx=indexes[-1])
             node = tip.get_node(path)
             node_indexes = [commit.idx for commit in node.history]
             assert set(indexes).issubset(set(node_indexes)), (
                 "We assumed that %s is subset of commits for which file %s "
                 "has been changed, and history of that node returned: %s"
                 % (indexes, path, node_indexes))
 
     def test_file_annotate(self):
         files = {
             'vcs/backends/__init__.py': {
                 89: {
                     'lines_no': 31,
                     'commits': [
                         32, 32, 61, 32, 32, 37, 32, 32, 32, 44,
                         37, 37, 37, 37, 45, 37, 44, 37, 37, 37,
                         32, 32, 32, 32, 37, 32, 37, 37, 32,
                         32, 32
                     ]
                 },
                 20: {
                     'lines_no': 1,
                     'commits': [4]
                 },
                 55: {
                     'lines_no': 31,
                     'commits': [
                         32, 32, 45, 32, 32, 37, 32, 32, 32, 44,
                         37, 37, 37, 37, 45, 37, 44, 37, 37, 37,
                         32, 32, 32, 32, 37, 32, 37, 37, 32,
                         32, 32
                     ]
                 }
             },
             'vcs/exceptions.py': {
                 89: {
                     'lines_no': 18,
                     'commits': [
                         16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
                         16, 16, 17, 16, 16, 18, 18, 18
                     ]
                 },
                 20: {
                     'lines_no': 18,
                     'commits': [
                         16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
                         16, 16, 17, 16, 16, 18, 18, 18
                     ]
                 },
                 55: {
                     'lines_no': 18,
                     'commits': [
                         16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
                         17, 16, 16, 18, 18, 18
                     ]
                 }
             },
             'MANIFEST.in': {
                 89: {
                     'lines_no': 5,
                     'commits': [7, 7, 7, 71, 71]
                 },
                 20: {
                     'lines_no': 3,
                     'commits': [7, 7, 7]
                 },
                 55: {
                     'lines_no': 3,
                     'commits': [7, 7, 7]
                 }
             }
         }
 
         for fname, commit_dict in files.items():
             for idx, __ in commit_dict.items():
                 commit = self.repo.get_commit(commit_idx=idx)
                 l1_1 = [x[1] for x in commit.get_file_annotate(fname)]
                 l1_2 = [x[2]().raw_id for x in commit.get_file_annotate(fname)]
                 assert l1_1 == l1_2
                 l1 = l1_2 = [
                     x[2]().idx for x in commit.get_file_annotate(fname)]
                 l2 = files[fname][idx]['commits']
                 assert l1 == l2, (
                     "The lists of commit for %s@commit_id%s"
                     "from annotation list should match each other,"
                     "got \n%s \nvs \n%s " % (fname, idx, l1, l2))
 
     def test_commit_state(self):
         """
         Tests which files have been added/changed/removed at particular commit
         """
 
         # commit_id 46ad32a4f974:
         # hg st --rev 46ad32a4f974
         #    changed: 13
         #    added:   20
         #    removed: 1
         changed = set([
             '.hgignore', 'README.rst', 'docs/conf.py', 'docs/index.rst',
             'setup.py', 'tests/test_hg.py', 'tests/test_nodes.py',
             'vcs/__init__.py', 'vcs/backends/__init__.py',
             'vcs/backends/base.py', 'vcs/backends/hg.py', 'vcs/nodes.py',
             'vcs/utils/__init__.py'])
 
         added = set([
             'docs/api/backends/hg.rst', 'docs/api/backends/index.rst',
             'docs/api/index.rst', 'docs/api/nodes.rst',
             'docs/api/web/index.rst', 'docs/api/web/simplevcs.rst',
             'docs/installation.rst', 'docs/quickstart.rst', 'setup.cfg',
             'vcs/utils/baseui_config.py', 'vcs/utils/web.py',
             'vcs/web/__init__.py', 'vcs/web/exceptions.py',
             'vcs/web/simplevcs/__init__.py', 'vcs/web/simplevcs/exceptions.py',
             'vcs/web/simplevcs/middleware.py', 'vcs/web/simplevcs/models.py',
             'vcs/web/simplevcs/settings.py', 'vcs/web/simplevcs/utils.py',
             'vcs/web/simplevcs/views.py'])
 
         removed = set(['docs/api.rst'])
 
         commit64 = self.repo.get_commit('46ad32a4f974')
         assert set((node.path for node in commit64.added)) == added
         assert set((node.path for node in commit64.changed)) == changed
         assert set((node.path for node in commit64.removed)) == removed
 
         # commit_id b090f22d27d6:
         # hg st --rev b090f22d27d6
         #    changed: 13
         #    added:   20
         #    removed: 1
         commit88 = self.repo.get_commit('b090f22d27d6')
         assert set((node.path for node in commit88.added)) == set()
         assert set((node.path for node in commit88.changed)) == \
             set(['.hgignore'])
         assert set((node.path for node in commit88.removed)) == set()
 
         #
         # 85:
         #    added:   2 [
         #       'vcs/utils/diffs.py', 'vcs/web/simplevcs/views/diffs.py']
         #    changed: 4 ['vcs/web/simplevcs/models.py', ...]
         #    removed: 1 ['vcs/utils/web.py']
         commit85 = self.repo.get_commit(commit_idx=85)
         assert set((node.path for node in commit85.added)) == set([
             'vcs/utils/diffs.py',
             'vcs/web/simplevcs/views/diffs.py'])
         assert set((node.path for node in commit85.changed)) == set([
             'vcs/web/simplevcs/models.py',
             'vcs/web/simplevcs/utils.py',
             'vcs/web/simplevcs/views/__init__.py',
             'vcs/web/simplevcs/views/repository.py',
             ])
         assert set((node.path for node in commit85.removed)) == \
             set(['vcs/utils/web.py'])
 
     def test_files_state(self):
         """
         Tests state of FileNodes.
         """
         commit = self.repo.get_commit(commit_idx=85)
         node = commit.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
 
         commit = self.repo.get_commit(commit_idx=88)
         node = commit.get_node('.hgignore')
         assert node.state, NodeState.CHANGED
         assert not node.added
         assert node.changed
         assert not node.not_changed
         assert not node.removed
 
         commit = self.repo.get_commit(commit_idx=85)
         node = commit.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
         # CommitError exception
         commit = self.repo.get_commit(commit_idx=2)
         path = 'vcs/backends/BaseRepository.py'
         with pytest.raises(NodeDoesNotExistError):
             commit.get_node(path)
         # but it would be one of ``removed`` (commit's attribute)
         assert path in [rf.path for rf in commit.removed]
 
     def test_commit_message_is_unicode(self):
         for cm in self.repo:
             assert type(cm.message) == unicode
 
     def test_commit_author_is_unicode(self):
         for cm in self.repo:
             assert type(cm.author) == unicode
 
     def test_repo_files_content_is_unicode(self):
         test_commit = self.repo.get_commit(commit_idx=100)
         for node in test_commit.get_node('/'):
             if node.is_file():
                 assert type(node.content) == unicode
 
     def test_wrong_path(self):
         # There is 'setup.py' in the root dir but not there:
         path = 'foo/bar/setup.py'
         with pytest.raises(VCSError):
             self.repo.get_commit().get_node(path)
 
     def test_author_email(self):
         assert '[e-mail]' == \
             self.repo.get_commit('b986218ba1c9').author_email
         assert '[e-mail]' == \
             self.repo.get_commit('3803844fdbd3').author_email
         assert '' == self.repo.get_commit('84478366594b').author_email
 
     def test_author_username(self):
         assert 'Marcin Kuzminski' == \
             self.repo.get_commit('b986218ba1c9').author_name
         assert 'Lukasz Balcerzak' == \
             self.repo.get_commit('3803844fdbd3').author_name
         assert 'marcink' == \
             self.repo.get_commit('84478366594b').author_name
 
 
 class TestLargeFileRepo(object):
 
     def test_large_file(self, backend_hg):
         repo = backend_hg.create_test_repo('largefiles', make_db_config())
 
         tip = repo.scm_instance().get_commit()
         node = tip.get_node('.hglf/thisfileislarge')
 
         lf_node = node.get_largefile_node()
 
         assert lf_node.is_largefile() is True
         assert lf_node.size == 1024000
         assert lf_node.name == '.hglf/thisfileislarge'
 
 
 class TestGetBranchName(object):
     def test_returns_ref_name_when_type_is_branch(self):
         ref = self._create_ref('branch', 'fake-name')
         result = self.repo._get_branch_name(ref)
         assert result == ref.name
 
     @pytest.mark.parametrize("type_", ("book", "tag"))
     def test_queries_remote_when_type_is_not_branch(self, type_):
         ref = self._create_ref(type_, 'wrong-fake-name')
         with mock.patch.object(self.repo, "_remote") as remote_mock:
             remote_mock.ctx_branch.return_value = "fake-name"
             result = self.repo._get_branch_name(ref)
         assert result == "fake-name"
         remote_mock.ctx_branch.assert_called_once_with(ref.commit_id)
 
     def _create_ref(self, type_, name):
         ref = mock.Mock()
         ref.type = type_
         ref.name = 'wrong-fake-name'
         ref.commit_id = "deadbeef"
         return ref
 
 
 class TestIsTheSameBranch(object):
     def test_returns_true_when_branches_are_equal(self):
         source_ref = mock.Mock(name="source-ref")
         target_ref = mock.Mock(name="target-ref")
         branch_name_patcher = mock.patch.object(
             self.repo, "_get_branch_name", return_value="default")
         with branch_name_patcher as branch_name_mock:
             result = self.repo._is_the_same_branch(source_ref, target_ref)
 
         expected_calls = [mock.call(source_ref), mock.call(target_ref)]
         assert branch_name_mock.call_args_list == expected_calls
         assert result is True
 
     def test_returns_false_when_branches_are_not_equal(self):
         source_ref = mock.Mock(name="source-ref")
         source_ref.name = "source-branch"
         target_ref = mock.Mock(name="target-ref")
         source_ref.name = "target-branch"
 
         def side_effect(ref):
             return ref.name
 
         branch_name_patcher = mock.patch.object(
             self.repo, "_get_branch_name", side_effect=side_effect)
         with branch_name_patcher as branch_name_mock:
             result = self.repo._is_the_same_branch(source_ref, target_ref)
 
         expected_calls = [mock.call(source_ref), mock.call(target_ref)]
         assert branch_name_mock.call_args_list == expected_calls
         assert result is False