largefiles: enabled download of largefiles for git and mercurial from web interface.

- fixes  #2817

default.nix

@@ -1,241 +1,241 b''
 # Nix environment for the community edition
 #
 # This shall be as lean as possible, just producing the Enterprise
 # derivation. For advanced tweaks to pimp up the development environment we use
 # "shell.nix" so that it does not have to clutter this file.
 
 args@
 { pythonPackages ? "python27Packages"
 , pythonExternalOverrides ? self: super: {}
 , doCheck ? true
 , ...
 }:
 
 let
 
   # Use nixpkgs from args or import them. We use this indirect approach
   # through args to be able to use the name `pkgs` for our customized packages.
   # Otherwise we will end up with an infinite recursion.
   nixpkgs = args.pkgs or (import <nixpkgs> { });
 
   # johbo: Interim bridge which allows us to build with the upcoming
   # nixos.16.09 branch (unstable at the moment of writing this note) and the
   # current stable nixos-16.03.
   backwardsCompatibleFetchgit = { ... }@args:
     let
       origSources = nixpkgs.fetchgit args;
     in
     nixpkgs.lib.overrideDerivation origSources (oldAttrs: {
       NIX_PREFETCH_GIT_CHECKOUT_HOOK = ''
         find $out -name '.git*' -print0 | xargs -0 rm -rf
       '';
     });
 
   # Create a customized version of nixpkgs which should be used throughout the
   # rest of this file.
   pkgs = nixpkgs.overridePackages (self: super: {
     fetchgit = backwardsCompatibleFetchgit;
   });
 
   # Evaluates to the last segment of a file system path.
   basename = path: with pkgs.lib; last (splitString "/" path);
 
   # source code filter used as arugment to builtins.filterSource.
   src-filter = path: type: with pkgs.lib;
     let
       ext = last (splitString "." path);
     in
       !builtins.elem (basename path) [
         ".git" ".hg" "__pycache__" ".eggs"
         "bower_components" "node_modules"
         "build" "data" "result" "tmp"] &&
       !builtins.elem ext ["egg-info" "pyc"] &&
       # TODO: johbo: This check is wrong, since "path" contains an absolute path,
       # it would still be good to restore it since we want to ignore "result-*".
       !hasPrefix "result" path;
 
   basePythonPackages = with builtins; if isAttrs pythonPackages
     then pythonPackages
     else getAttr pythonPackages pkgs;
 
   buildBowerComponents =
     pkgs.buildBowerComponents or
     (import ./pkgs/backport-16.03-build-bower-components.nix { inherit pkgs; });
 
   sources = pkgs.config.rc.sources or {};
   version = builtins.readFile ./rhodecode/VERSION;
   rhodecode-enterprise-ce-src = builtins.filterSource src-filter ./.;
 
   nodeEnv = import ./pkgs/node-default.nix {
     inherit pkgs;
   };
   nodeDependencies = nodeEnv.shell.nodeDependencies;
 
   bowerComponents = buildBowerComponents {
     name = "enterprise-ce-${version}";
     generated = ./pkgs/bower-packages.nix;
     src = rhodecode-enterprise-ce-src;
   };
 
   pythonGeneratedPackages = self: basePythonPackages.override (a: {
     inherit self;
   })
   // (scopedImport {
     self = self;
     super = basePythonPackages;
     inherit pkgs;
     inherit (pkgs) fetchurl fetchgit;
   } ./pkgs/python-packages.nix);
 
   pythonOverrides = import ./pkgs/python-packages-overrides.nix {
     inherit
       basePythonPackages
       pkgs;
   };
 
   pythonLocalOverrides = self: super: {
     rhodecode-enterprise-ce =
       let
         linkNodeAndBowerPackages = ''
           echo "Export RhodeCode CE path"
           export RHODECODE_CE_PATH=${rhodecode-enterprise-ce-src}
           echo "Link node packages"
           rm -fr node_modules
           mkdir node_modules
           # johbo: Linking individual packages allows us to run "npm install"
           # inside of a shell to try things out. Re-entering the shell will
           # restore a clean environment.
           ln -s ${nodeDependencies}/lib/node_modules/* node_modules/
 
           echo "DONE: Link node packages"
 
           echo "Link bower packages"
           rm -fr bower_components
           mkdir bower_components
 
           ln -s ${bowerComponents}/bower_components/* bower_components/
           echo "DONE: Link bower packages"
         '';
       in super.rhodecode-enterprise-ce.override (attrs: {
 
       inherit
         doCheck
         version;
       name = "rhodecode-enterprise-ce-${version}";
       releaseName = "RhodeCodeEnterpriseCE-${version}";
       src = rhodecode-enterprise-ce-src;
       dontStrip = true; # prevent strip, we don't need it.
 
       buildInputs =
         attrs.buildInputs ++
         (with self; [
           pkgs.nodePackages.bower
           pkgs.nodePackages.grunt-cli
           pkgs.subversion
           pytest-catchlog
           rhodecode-testdata
         ]);
 
       #TODO: either move this into overrides, OR use the new machanics from
       # pip2nix and requiremtn.txt file
       propagatedBuildInputs = attrs.propagatedBuildInputs ++ (with self; [
         rhodecode-tools
       ]);
 
       # TODO: johbo: Make a nicer way to expose the parts. Maybe
       # pkgs/default.nix?
       passthru = {
         inherit
           bowerComponents
           linkNodeAndBowerPackages
           myPythonPackagesUnfix
           pythonLocalOverrides;
         pythonPackages = self;
       };
 
       LC_ALL = "en_US.UTF-8";
       LOCALE_ARCHIVE =
         if pkgs.stdenv ? glibc
         then "${pkgs.glibcLocales}/lib/locale/locale-archive"
         else "";
 
       preCheck = ''
         export PATH="$out/bin:$PATH"
       '';
 
       postCheck = ''
         rm -rf $out/lib/${self.python.libPrefix}/site-packages/pytest_pylons
         rm -rf $out/lib/${self.python.libPrefix}/site-packages/rhodecode/tests
       '';
 
       preBuild = linkNodeAndBowerPackages + ''
         grunt
         rm -fr node_modules
       '';
 
       postInstall = ''
         # python based programs need to be wrapped
         ln -s ${self.supervisor}/bin/supervisor* $out/bin/
         ln -s ${self.gunicorn}/bin/gunicorn $out/bin/
         ln -s ${self.PasteScript}/bin/paster $out/bin/
         ln -s ${self.channelstream}/bin/channelstream $out/bin/
         ln -s ${self.pyramid}/bin/* $out/bin/  #*/
 
         # rhodecode-tools
         # TODO: johbo: re-think this. Do the tools import anything from enterprise?
         ln -s ${self.rhodecode-tools}/bin/rhodecode-* $out/bin/
 
         # note that condition should be restricted when adding further tools
         for file in $out/bin/*; do  #*/
           wrapProgram $file \
               --prefix PYTHONPATH : $PYTHONPATH \
               --prefix PATH : $PATH \
               --set PYTHONHASHSEED random
         done
 
         mkdir $out/etc
         cp configs/production.ini $out/etc
 
         echo "Writing meta information for rccontrol to nix-support/rccontrol"
         mkdir -p $out/nix-support/rccontrol
         cp -v rhodecode/VERSION $out/nix-support/rccontrol/version
         echo "DONE: Meta information for rccontrol written"
 
         # TODO: johbo: Make part of ac-tests
         if [ ! -f rhodecode/public/js/scripts.js ]; then
           echo "Missing scripts.js"
           exit 1
         fi
         if [ ! -f rhodecode/public/css/style.css ]; then
           echo "Missing style.css"
           exit 1
         fi
       '';
 
     });
 
     rhodecode-testdata = import "${rhodecode-testdata-src}/default.nix" {
     inherit
       doCheck
       pkgs
       pythonPackages;
     };
 
   };
 
   rhodecode-testdata-src = sources.rhodecode-testdata or (
     pkgs.fetchhg {
       url = "https://code.rhodecode.com/upstream/rc_testdata";
-      rev = "v0.9.0";
-      sha256 = "0k0ccb7cncd6mmzwckfbr6l7fsymcympwcm948qc3i0f0m6bbg1y";
+      rev = "v0.10.0";
+      sha256 = "0zn9swwvx4vgw4qn8q3ri26vvzgrxn15x6xnjrysi1bwmz01qjl0";
   });
 
   # Apply all overrides and fix the final package set
   myPythonPackagesUnfix = with pkgs.lib;
     (extends pythonExternalOverrides
     (extends pythonLocalOverrides
     (extends pythonOverrides
              pythonGeneratedPackages)));
   myPythonPackages = (pkgs.lib.fix myPythonPackagesUnfix);
 
 in myPythonPackages.rhodecode-enterprise-ce

rhodecode/controllers/files.py

@@ -1,1087 +1,1097 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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/
 
 """
 Files controller for RhodeCode Enterprise
 """
 
 import itertools
 import logging
 import os
 import shutil
 import tempfile
 
 from pylons import request, response, tmpl_context as c, url
 from pylons.i18n.translation import _
 from pylons.controllers.util import redirect
 from webob.exc import HTTPNotFound, HTTPBadRequest
 
 from rhodecode.controllers.utils import parse_path_ref
 from rhodecode.lib import diffs, helpers as h, caches
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.codeblocks import (
     filenode_as_lines_tokens, filenode_as_annotated_lines_tokens)
 from rhodecode.lib.utils import jsonify, action_logger
 from rhodecode.lib.utils2 import (
     convert_line_endings, detect_mode, safe_str, str2bool)
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, CSRFRequired, XHRRequired)
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.vcs import path as vcspath
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import (
     RepositoryError, CommitDoesNotExistError, EmptyRepositoryError,
     ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError,
     NodeDoesNotExistError, CommitError, NodeError)
 from rhodecode.lib.vcs.nodes import FileNode
 
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.db import Repository
 
 from rhodecode.controllers.changeset import (
     _ignorews_url, _context_url, get_line_ctx, get_ignore_ws)
 from rhodecode.lib.exceptions import NonRelativePathError
 
 log = logging.getLogger(__name__)
 
 
 class FilesController(BaseRepoController):
 
     def __before__(self):
         super(FilesController, self).__before__()
         c.cut_off_limit = self.cut_off_limit_file
 
     def _get_default_encoding(self):
         enc_list = getattr(c, 'default_encodings', [])
         return enc_list[0] if enc_list else 'UTF-8'
 
     def __get_commit_or_redirect(self, commit_id, repo_name,
                                  redirect_after=True):
         """
         This is a safe way to get commit. If an error occurs it redirects to
         tip with proper message
 
         :param commit_id: id of commit to fetch
         :param repo_name: repo name to redirect after
         :param redirect_after: toggle redirection
         """
         try:
             return c.rhodecode_repo.get_commit(commit_id)
         except EmptyRepositoryError:
             if not redirect_after:
                 return None
             url_ = url('files_add_home',
                        repo_name=c.repo_name,
                        revision=0, f_path='', anchor='edit')
             if h.HasRepoPermissionAny(
                     'repository.write', 'repository.admin')(c.repo_name):
                 add_new = h.link_to(
                     _('Click here to add a new file.'),
                     url_, class_="alert-link")
             else:
                 add_new = ""
             h.flash(h.literal(
                 _('There are no files yet. %s') % add_new), category='warning')
             redirect(h.url('summary_home', repo_name=repo_name))
         except (CommitDoesNotExistError, LookupError):
             msg = _('No such commit exists for this repository')
             h.flash(msg, category='error')
             raise HTTPNotFound()
         except RepositoryError as e:
             h.flash(safe_str(e), category='error')
             raise HTTPNotFound()
 
     def __get_filenode_or_redirect(self, repo_name, commit, path):
         """
         Returns file_node, if error occurs or given path is directory,
         it'll redirect to top level path
 
         :param repo_name: repo_name
         :param commit: given commit
         :param path: path to lookup
         """
         try:
             file_node = commit.get_node(path)
             if file_node.is_dir():
                 raise RepositoryError('The given path is a directory')
         except CommitDoesNotExistError:
             msg = _('No such commit exists for this repository')
             log.exception(msg)
             h.flash(msg, category='error')
             raise HTTPNotFound()
         except RepositoryError as e:
             h.flash(safe_str(e), category='error')
             raise HTTPNotFound()
 
         return file_node
 
     def __get_tree_cache_manager(self, repo_name, namespace_type):
         _namespace = caches.get_repo_namespace_key(namespace_type, repo_name)
         return caches.get_cache_manager('repo_cache_long', _namespace)
 
     def _get_tree_at_commit(self, repo_name, commit_id, f_path,
                             full_load=False, force=False):
         def _cached_tree():
             log.debug('Generating cached file tree for %s, %s, %s',
                       repo_name, commit_id, f_path)
             c.full_load = full_load
             return render('files/files_browser_tree.mako')
 
         cache_manager = self.__get_tree_cache_manager(
             repo_name, caches.FILE_TREE)
 
         cache_key = caches.compute_key_from_params(
             repo_name, commit_id, f_path)
 
         if force:
             # we want to force recompute of caches
             cache_manager.remove_value(cache_key)
 
         return cache_manager.get(cache_key, createfunc=_cached_tree)
 
     def _get_nodelist_at_commit(self, repo_name, commit_id, f_path):
         def _cached_nodes():
             log.debug('Generating cached nodelist for %s, %s, %s',
                       repo_name, commit_id, f_path)
             _d, _f = ScmModel().get_nodes(
                 repo_name, commit_id, f_path, flat=False)
             return _d + _f
 
         cache_manager = self.__get_tree_cache_manager(
             repo_name, caches.FILE_SEARCH_TREE_META)
 
         cache_key = caches.compute_key_from_params(
             repo_name, commit_id, f_path)
         return cache_manager.get(cache_key, createfunc=_cached_nodes)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     def index(
             self, repo_name, revision, f_path, annotate=False, rendered=False):
         commit_id = revision
 
         # redirect to given commit_id from form if given
         get_commit_id = request.GET.get('at_rev', None)
         if get_commit_id:
             self.__get_commit_or_redirect(get_commit_id, repo_name)
 
         c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
         c.branch = request.GET.get('branch', None)
         c.f_path = f_path
         c.annotate = annotate
         # default is false, but .rst/.md files later are autorendered, we can
         # overwrite autorendering by setting this GET flag
         c.renderer = rendered or not request.GET.get('no-render', False)
 
         # prev link
         try:
             prev_commit = c.commit.prev(c.branch)
             c.prev_commit = prev_commit
             c.url_prev = url('files_home', repo_name=c.repo_name,
                              revision=prev_commit.raw_id, f_path=f_path)
             if c.branch:
                 c.url_prev += '?branch=%s' % c.branch
         except (CommitDoesNotExistError, VCSError):
             c.url_prev = '#'
             c.prev_commit = EmptyCommit()
 
         # next link
         try:
             next_commit = c.commit.next(c.branch)
             c.next_commit = next_commit
             c.url_next = url('files_home', repo_name=c.repo_name,
                              revision=next_commit.raw_id, f_path=f_path)
             if c.branch:
                 c.url_next += '?branch=%s' % c.branch
         except (CommitDoesNotExistError, VCSError):
             c.url_next = '#'
             c.next_commit = EmptyCommit()
 
         # files or dirs
         try:
             c.file = c.commit.get_node(f_path)
             c.file_author = True
             c.file_tree = ''
             if c.file.is_file():
+                c.lf_node = c.file.get_largefile_node()
+
                 c.file_source_page = 'true'
                 c.file_last_commit = c.file.last_commit
                 if c.file.size < self.cut_off_limit_file:
                     if c.annotate:  # annotation has precedence over renderer
                         c.annotated_lines = filenode_as_annotated_lines_tokens(
                             c.file
                         )
                     else:
                         c.renderer = (
                             c.renderer and h.renderer_from_filename(c.file.path)
                         )
                         if not c.renderer:
                             c.lines = filenode_as_lines_tokens(c.file)
 
                 c.on_branch_head = self._is_valid_head(
                     commit_id, c.rhodecode_repo)
                 c.branch_or_raw_id = c.commit.branch or c.commit.raw_id
 
                 author = c.file_last_commit.author
                 c.authors = [(h.email(author),
                               h.person(author, 'username_or_name_or_email'))]
             else:
                 c.file_source_page = 'false'
                 c.authors = []
                 c.file_tree = self._get_tree_at_commit(
                     repo_name, c.commit.raw_id, f_path)
 
         except RepositoryError as e:
             h.flash(safe_str(e), category='error')
             raise HTTPNotFound()
 
         if request.environ.get('HTTP_X_PJAX'):
             return render('files/files_pjax.mako')
 
         return render('files/files.mako')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     def annotate_previous(self, repo_name, revision, f_path):
 
         commit_id = revision
         commit = self.__get_commit_or_redirect(commit_id, repo_name)
         prev_commit_id = commit.raw_id
 
         f_path = f_path
         is_file = False
         try:
             _file = commit.get_node(f_path)
             is_file = _file.is_file()
         except (NodeDoesNotExistError, CommitDoesNotExistError, VCSError):
             pass
 
         if is_file:
             history = commit.get_file_history(f_path)
             prev_commit_id = history[1].raw_id \
                 if len(history) > 1 else prev_commit_id
 
         return redirect(h.url(
             'files_annotate_home', repo_name=repo_name,
             revision=prev_commit_id, f_path=f_path))
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def history(self, repo_name, revision, f_path):
         commit = self.__get_commit_or_redirect(revision, repo_name)
         f_path = f_path
         _file = commit.get_node(f_path)
         if _file.is_file():
             file_history, _hist = self._get_node_history(commit, f_path)
 
             res = []
             for obj in file_history:
                 res.append({
                     'text': obj[1],
                     'children': [{'id': o[0], 'text': o[1]} for o in obj[0]]
                 })
 
             data = {
                 'more': False,
                 'results': res
             }
             return data
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def authors(self, repo_name, revision, f_path):
         commit = self.__get_commit_or_redirect(revision, repo_name)
         file_node = commit.get_node(f_path)
         if file_node.is_file():
             c.file_last_commit = file_node.last_commit
             if request.GET.get('annotate') == '1':
                 # use _hist from annotation if annotation mode is on
                 commit_ids = set(x[1] for x in file_node.annotate)
                 _hist = (
                     c.rhodecode_repo.get_commit(commit_id)
                     for commit_id in commit_ids)
             else:
                 _f_history, _hist = self._get_node_history(commit, f_path)
             c.file_author = False
             c.authors = []
             for author in set(commit.author for commit in _hist):
                 c.authors.append((
                     h.email(author),
                     h.person(author, 'username_or_name_or_email')))
             return render('files/file_authors_box.mako')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def rawfile(self, repo_name, revision, f_path):
         """
         Action for download as raw
         """
         commit = self.__get_commit_or_redirect(revision, repo_name)
         file_node = self.__get_filenode_or_redirect(repo_name, commit, f_path)
 
+        if request.GET.get('lf'):
+            # only if lf get flag is passed, we download this file
+            # as LFS/Largefile
+            lf_node = file_node.get_largefile_node()
+            if lf_node:
+                # overwrite our pointer with the REAL large-file
+                file_node = lf_node
+
         response.content_disposition = 'attachment; filename=%s' % \
             safe_str(f_path.split(Repository.NAME_SEP)[-1])
 
         response.content_type = file_node.mimetype
         charset = self._get_default_encoding()
         if charset:
             response.charset = charset
 
         return file_node.content
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def raw(self, repo_name, revision, f_path):
         """
         Action for show as raw, some mimetypes are "rendered",
         those include images, icons.
         """
         commit = self.__get_commit_or_redirect(revision, repo_name)
         file_node = self.__get_filenode_or_redirect(repo_name, commit, f_path)
 
         raw_mimetype_mapping = {
             # map original mimetype to a mimetype used for "show as raw"
             # you can also provide a content-disposition to override the
             # default "attachment" disposition.
             # orig_type: (new_type, new_dispo)
 
             # show images inline:
             # Do not re-add SVG: it is unsafe and permits XSS attacks. One can
             # for example render an SVG with javascript inside or even render
             # HTML.
             'image/x-icon': ('image/x-icon', 'inline'),
             'image/png': ('image/png', 'inline'),
             'image/gif': ('image/gif', 'inline'),
             'image/jpeg': ('image/jpeg', 'inline'),
         }
 
         mimetype = file_node.mimetype
         try:
             mimetype, dispo = raw_mimetype_mapping[mimetype]
         except KeyError:
             # we don't know anything special about this, handle it safely
             if file_node.is_binary:
                 # do same as download raw for binary files
                 mimetype, dispo = 'application/octet-stream', 'attachment'
             else:
                 # do not just use the original mimetype, but force text/plain,
                 # otherwise it would serve text/html and that might be unsafe.
                 # Note: underlying vcs library fakes text/plain mimetype if the
                 # mimetype can not be determined and it thinks it is not
                 # binary.This might lead to erroneous text display in some
                 # cases, but helps in other cases, like with text files
                 # without extension.
                 mimetype, dispo = 'text/plain', 'inline'
 
         if dispo == 'attachment':
             dispo = 'attachment; filename=%s' % safe_str(
                 f_path.split(os.sep)[-1])
 
         response.content_disposition = dispo
         response.content_type = mimetype
         charset = self._get_default_encoding()
         if charset:
             response.charset = charset
         return file_node.content
 
     @CSRFRequired()
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     def delete(self, repo_name, revision, f_path):
         commit_id = revision
 
         repo = c.rhodecode_db_repo
         if repo.enable_locking and repo.locked[0]:
             h.flash(_('This repository has been locked by %s on %s')
                     % (h.person_by_id(repo.locked[0]),
                     h.format_date(h.time_to_datetime(repo.locked[1]))),
                     'warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip'))
 
         if not self._is_valid_head(commit_id, repo.scm_instance()):
             h.flash(_('You can only delete files with revision '
                       'being a valid branch '), category='warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip',
                                   f_path=f_path))
 
         c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
         c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
 
         c.default_message = _(
             'Deleted file %s via RhodeCode Enterprise') % (f_path)
         c.f_path = f_path
         node_path = f_path
         author = c.rhodecode_user.full_contact
         message = request.POST.get('message') or c.default_message
         try:
             nodes = {
                 node_path: {
                     'content': ''
                 }
             }
             self.scm_model.delete_nodes(
                 user=c.rhodecode_user.user_id, repo=c.rhodecode_db_repo,
                 message=message,
                 nodes=nodes,
                 parent_commit=c.commit,
                 author=author,
             )
 
             h.flash(_('Successfully deleted file %s') % f_path,
                     category='success')
         except Exception:
             msg = _('Error occurred during commit')
             log.exception(msg)
             h.flash(msg, category='error')
         return redirect(url('changeset_home',
                             repo_name=c.repo_name, revision='tip'))
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     def delete_home(self, repo_name, revision, f_path):
         commit_id = revision
 
         repo = c.rhodecode_db_repo
         if repo.enable_locking and repo.locked[0]:
             h.flash(_('This repository has been locked by %s on %s')
                     % (h.person_by_id(repo.locked[0]),
                     h.format_date(h.time_to_datetime(repo.locked[1]))),
                     'warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip'))
 
         if not self._is_valid_head(commit_id, repo.scm_instance()):
             h.flash(_('You can only delete files with revision '
                       'being a valid branch '), category='warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip',
                                   f_path=f_path))
 
         c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
         c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
 
         c.default_message = _(
             'Deleted file %s via RhodeCode Enterprise') % (f_path)
         c.f_path = f_path
 
         return render('files/files_delete.mako')
 
     @CSRFRequired()
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     def edit(self, repo_name, revision, f_path):
         commit_id = revision
 
         repo = c.rhodecode_db_repo
         if repo.enable_locking and repo.locked[0]:
             h.flash(_('This repository has been locked by %s on %s')
                     % (h.person_by_id(repo.locked[0]),
                     h.format_date(h.time_to_datetime(repo.locked[1]))),
                     'warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip'))
 
         if not self._is_valid_head(commit_id, repo.scm_instance()):
             h.flash(_('You can only edit files with revision '
                       'being a valid branch '), category='warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip',
                                   f_path=f_path))
 
         c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
         c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
 
         if c.file.is_binary:
             return redirect(url('files_home', repo_name=c.repo_name,
                             revision=c.commit.raw_id, f_path=f_path))
         c.default_message = _(
             'Edited file %s via RhodeCode Enterprise') % (f_path)
         c.f_path = f_path
         old_content = c.file.content
         sl = old_content.splitlines(1)
         first_line = sl[0] if sl else ''
 
         # modes:  0 - Unix, 1 - Mac, 2 - DOS
         mode = detect_mode(first_line, 0)
         content = convert_line_endings(request.POST.get('content', ''), mode)
 
         message = request.POST.get('message') or c.default_message
         org_f_path = c.file.unicode_path
         filename = request.POST['filename']
         org_filename = c.file.name
 
         if content == old_content and filename == org_filename:
             h.flash(_('No changes'), category='warning')
             return redirect(url('changeset_home', repo_name=c.repo_name,
                                 revision='tip'))
         try:
             mapping = {
                 org_f_path: {
                     'org_filename': org_f_path,
                     'filename': os.path.join(c.file.dir_path, filename),
                     'content': content,
                     'lexer': '',
                     'op': 'mod',
                 }
             }
 
             ScmModel().update_nodes(
                 user=c.rhodecode_user.user_id,
                 repo=c.rhodecode_db_repo,
                 message=message,
                 nodes=mapping,
                 parent_commit=c.commit,
             )
 
             h.flash(_('Successfully committed to %s') % f_path,
                     category='success')
         except Exception:
             msg = _('Error occurred during commit')
             log.exception(msg)
             h.flash(msg, category='error')
         return redirect(url('changeset_home',
                             repo_name=c.repo_name, revision='tip'))
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     def edit_home(self, repo_name, revision, f_path):
         commit_id = revision
 
         repo = c.rhodecode_db_repo
         if repo.enable_locking and repo.locked[0]:
             h.flash(_('This repository has been locked by %s on %s')
                     % (h.person_by_id(repo.locked[0]),
                     h.format_date(h.time_to_datetime(repo.locked[1]))),
                     'warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip'))
 
         if not self._is_valid_head(commit_id, repo.scm_instance()):
             h.flash(_('You can only edit files with revision '
                       'being a valid branch '), category='warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip',
                                   f_path=f_path))
 
         c.commit = self.__get_commit_or_redirect(commit_id, repo_name)
         c.file = self.__get_filenode_or_redirect(repo_name, c.commit, f_path)
 
         if c.file.is_binary:
             return redirect(url('files_home', repo_name=c.repo_name,
                             revision=c.commit.raw_id, f_path=f_path))
         c.default_message = _(
             'Edited file %s via RhodeCode Enterprise') % (f_path)
         c.f_path = f_path
 
         return render('files/files_edit.mako')
 
     def _is_valid_head(self, commit_id, repo):
         # check if commit is a branch identifier- basically we cannot
         # create multiple heads via file editing
         valid_heads = repo.branches.keys() + repo.branches.values()
 
         if h.is_svn(repo) and not repo.is_empty():
             # Note: Subversion only has one head, we add it here in case there
             # is no branch matched.
             valid_heads.append(repo.get_commit(commit_idx=-1).raw_id)
 
         # check if commit is a branch name or branch hash
         return commit_id in valid_heads
 
     @CSRFRequired()
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     def add(self, repo_name, revision, f_path):
         repo = Repository.get_by_repo_name(repo_name)
         if repo.enable_locking and repo.locked[0]:
             h.flash(_('This repository has been locked by %s on %s')
                     % (h.person_by_id(repo.locked[0]),
                     h.format_date(h.time_to_datetime(repo.locked[1]))),
                     'warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip'))
 
         r_post = request.POST
 
         c.commit = self.__get_commit_or_redirect(
             revision, repo_name, redirect_after=False)
         if c.commit is None:
             c.commit = EmptyCommit(alias=c.rhodecode_repo.alias)
         c.default_message = (_('Added file via RhodeCode Enterprise'))
         c.f_path = f_path
         unix_mode = 0
         content = convert_line_endings(r_post.get('content', ''), unix_mode)
 
         message = r_post.get('message') or c.default_message
         filename = r_post.get('filename')
         location = r_post.get('location', '')  # dir location
         file_obj = r_post.get('upload_file', None)
 
         if file_obj is not None and hasattr(file_obj, 'filename'):
             filename = file_obj.filename
             content = file_obj.file
 
             if hasattr(content, 'file'):
                 # non posix systems store real file under file attr
                 content = content.file
 
         # If there's no commit, redirect to repo summary
         if type(c.commit) is EmptyCommit:
             redirect_url = "summary_home"
         else:
             redirect_url = "changeset_home"
 
         if not filename:
             h.flash(_('No filename'), category='warning')
             return redirect(url(redirect_url, repo_name=c.repo_name,
                                 revision='tip'))
 
         # extract the location from filename,
         # allows using foo/bar.txt syntax to create subdirectories
         subdir_loc = filename.rsplit('/', 1)
         if len(subdir_loc) == 2:
             location = os.path.join(location, subdir_loc[0])
 
         # strip all crap out of file, just leave the basename
         filename = os.path.basename(filename)
         node_path = os.path.join(location, filename)
         author = c.rhodecode_user.full_contact
 
         try:
             nodes = {
                 node_path: {
                     'content': content
                 }
             }
             self.scm_model.create_nodes(
                 user=c.rhodecode_user.user_id,
                 repo=c.rhodecode_db_repo,
                 message=message,
                 nodes=nodes,
                 parent_commit=c.commit,
                 author=author,
             )
 
             h.flash(_('Successfully committed to %s') % node_path,
                     category='success')
         except NonRelativePathError as e:
             h.flash(_(
                 'The location specified must be a relative path and must not '
                 'contain .. in the path'), category='warning')
             return redirect(url('changeset_home', repo_name=c.repo_name,
                                 revision='tip'))
         except (NodeError, NodeAlreadyExistsError) as e:
             h.flash(_(e), category='error')
         except Exception:
             msg = _('Error occurred during commit')
             log.exception(msg)
             h.flash(msg, category='error')
         return redirect(url('changeset_home',
                             repo_name=c.repo_name, revision='tip'))
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     def add_home(self, repo_name, revision, f_path):
 
         repo = Repository.get_by_repo_name(repo_name)
         if repo.enable_locking and repo.locked[0]:
             h.flash(_('This repository has been locked by %s on %s')
                     % (h.person_by_id(repo.locked[0]),
                     h.format_date(h.time_to_datetime(repo.locked[1]))),
                     'warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip'))
 
         c.commit = self.__get_commit_or_redirect(
             revision, repo_name, redirect_after=False)
         if c.commit is None:
             c.commit = EmptyCommit(alias=c.rhodecode_repo.alias)
         c.default_message = (_('Added file via RhodeCode Enterprise'))
         c.f_path = f_path
 
         return render('files/files_add.mako')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def archivefile(self, repo_name, fname):
         fileformat = None
         commit_id = None
         ext = None
         subrepos = request.GET.get('subrepos') == 'true'
 
         for a_type, ext_data in settings.ARCHIVE_SPECS.items():
             archive_spec = fname.split(ext_data[1])
             if len(archive_spec) == 2 and archive_spec[1] == '':
                 fileformat = a_type or ext_data[1]
                 commit_id = archive_spec[0]
                 ext = ext_data[1]
 
         dbrepo = RepoModel().get_by_repo_name(repo_name)
         if not dbrepo.enable_downloads:
             return _('Downloads disabled')
 
         try:
             commit = c.rhodecode_repo.get_commit(commit_id)
             content_type = settings.ARCHIVE_SPECS[fileformat][0]
         except CommitDoesNotExistError:
             return _('Unknown revision %s') % commit_id
         except EmptyRepositoryError:
             return _('Empty repository')
         except KeyError:
             return _('Unknown archive type')
 
         # archive cache
         from rhodecode import CONFIG
 
         archive_name = '%s-%s%s%s' % (
             safe_str(repo_name.replace('/', '_')),
             '-sub' if subrepos else '',
             safe_str(commit.short_id), ext)
 
         use_cached_archive = False
         archive_cache_enabled = CONFIG.get(
             'archive_cache_dir') and not request.GET.get('no_cache')
 
         if archive_cache_enabled:
             # check if we it's ok to write
             if not os.path.isdir(CONFIG['archive_cache_dir']):
                 os.makedirs(CONFIG['archive_cache_dir'])
             cached_archive_path = os.path.join(
                 CONFIG['archive_cache_dir'], archive_name)
             if os.path.isfile(cached_archive_path):
                 log.debug('Found cached archive in %s', cached_archive_path)
                 fd, archive = None, cached_archive_path
                 use_cached_archive = True
             else:
                 log.debug('Archive %s is not yet cached', archive_name)
 
         if not use_cached_archive:
             # generate new archive
             fd, archive = tempfile.mkstemp()
             log.debug('Creating new temp archive in %s' % (archive,))
             try:
                 commit.archive_repo(archive, kind=fileformat, subrepos=subrepos)
             except ImproperArchiveTypeError:
                 return _('Unknown archive type')
             if archive_cache_enabled:
                 # if we generated the archive and we have cache enabled
                 # let's use this for future
                 log.debug('Storing new archive in %s' % (cached_archive_path,))
                 shutil.move(archive, cached_archive_path)
                 archive = cached_archive_path
 
         def get_chunked_archive(archive):
             with open(archive, 'rb') as stream:
                 while True:
                     data = stream.read(16 * 1024)
                     if not data:
                         if fd:  # fd means we used temporary file
                             os.close(fd)
                         if not archive_cache_enabled:
                             log.debug('Destroying temp archive %s', archive)
                             os.remove(archive)
                         break
                     yield data
 
         # store download action
         action_logger(user=c.rhodecode_user,
                       action='user_downloaded_archive:%s' % archive_name,
                       repo=repo_name, ipaddr=self.ip_addr, commit=True)
         response.content_disposition = str(
             'attachment; filename=%s' % archive_name)
         response.content_type = str(content_type)
 
         return get_chunked_archive(archive)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def diff(self, repo_name, f_path):
 
         c.action = request.GET.get('diff')
         diff1 = request.GET.get('diff1', '')
         diff2 = request.GET.get('diff2', '')
 
         path1, diff1 = parse_path_ref(diff1, default_path=f_path)
 
         ignore_whitespace = str2bool(request.GET.get('ignorews'))
         line_context = request.GET.get('context', 3)
 
         if not any((diff1, diff2)):
             h.flash(
                 'Need query parameter "diff1" or "diff2" to generate a diff.',
                 category='error')
             raise HTTPBadRequest()
 
         if c.action not in ['download', 'raw']:
             # redirect to new view if we render diff
             return redirect(
                 url('compare_url', repo_name=repo_name,
                     source_ref_type='rev',
                     source_ref=diff1,
                     target_repo=c.repo_name,
                     target_ref_type='rev',
                     target_ref=diff2,
                     f_path=f_path))
 
         try:
             node1 = self._get_file_node(diff1, path1)
             node2 = self._get_file_node(diff2, f_path)
         except (RepositoryError, NodeError):
             log.exception("Exception while trying to get node from repository")
             return redirect(url(
                 'files_home', repo_name=c.repo_name, f_path=f_path))
 
         if all(isinstance(node.commit, EmptyCommit)
                for node in (node1, node2)):
             raise HTTPNotFound
 
         c.commit_1 = node1.commit
         c.commit_2 = node2.commit
 
         if c.action == 'download':
             _diff = diffs.get_gitdiff(node1, node2,
                                       ignore_whitespace=ignore_whitespace,
                                       context=line_context)
             diff = diffs.DiffProcessor(_diff, format='gitdiff')
 
             diff_name = '%s_vs_%s.diff' % (diff1, diff2)
             response.content_type = 'text/plain'
             response.content_disposition = (
                 'attachment; filename=%s' % (diff_name,)
             )
             charset = self._get_default_encoding()
             if charset:
                 response.charset = charset
             return diff.as_raw()
 
         elif c.action == 'raw':
             _diff = diffs.get_gitdiff(node1, node2,
                                       ignore_whitespace=ignore_whitespace,
                                       context=line_context)
             diff = diffs.DiffProcessor(_diff, format='gitdiff')
             response.content_type = 'text/plain'
             charset = self._get_default_encoding()
             if charset:
                 response.charset = charset
             return diff.as_raw()
 
         else:
             return redirect(
                 url('compare_url', repo_name=repo_name,
                     source_ref_type='rev',
                     source_ref=diff1,
                     target_repo=c.repo_name,
                     target_ref_type='rev',
                     target_ref=diff2,
                     f_path=f_path))
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def diff_2way(self, repo_name, f_path):
         """
         Kept only to make OLD links work
         """
         diff1 = request.GET.get('diff1', '')
         diff2 = request.GET.get('diff2', '')
 
         if not any((diff1, diff2)):
             h.flash(
                 'Need query parameter "diff1" or "diff2" to generate a diff.',
                 category='error')
             raise HTTPBadRequest()
 
         return redirect(
             url('compare_url', repo_name=repo_name,
                 source_ref_type='rev',
                 source_ref=diff1,
                 target_repo=c.repo_name,
                 target_ref_type='rev',
                 target_ref=diff2,
                 f_path=f_path,
                 diffmode='sideside'))
 
     def _get_file_node(self, commit_id, f_path):
         if commit_id not in ['', None, 'None', '0' * 12, '0' * 40]:
             commit = c.rhodecode_repo.get_commit(commit_id=commit_id)
             try:
                 node = commit.get_node(f_path)
                 if node.is_dir():
                     raise NodeError('%s path is a %s not a file'
                                     % (node, type(node)))
             except NodeDoesNotExistError:
                 commit = EmptyCommit(
                     commit_id=commit_id,
                     idx=commit.idx,
                     repo=commit.repository,
                     alias=commit.repository.alias,
                     message=commit.message,
                     author=commit.author,
                     date=commit.date)
                 node = FileNode(f_path, '', commit=commit)
         else:
             commit = EmptyCommit(
                 repo=c.rhodecode_repo,
                 alias=c.rhodecode_repo.alias)
             node = FileNode(f_path, '', commit=commit)
         return node
 
     def _get_node_history(self, commit, f_path, commits=None):
         """
         get commit history for given node
 
         :param commit: commit to calculate history
         :param f_path: path for node to calculate history for
         :param commits: if passed don't calculate history and take
             commits defined in this list
         """
         # calculate history based on tip
         tip = c.rhodecode_repo.get_commit()
         if commits is None:
             pre_load = ["author", "branch"]
             try:
                 commits = tip.get_file_history(f_path, pre_load=pre_load)
             except (NodeDoesNotExistError, CommitError):
                 # this node is not present at tip!
                 commits = commit.get_file_history(f_path, pre_load=pre_load)
 
         history = []
         commits_group = ([], _("Changesets"))
         for commit in commits:
             branch = ' (%s)' % commit.branch if commit.branch else ''
             n_desc = 'r%s:%s%s' % (commit.idx, commit.short_id, branch)
             commits_group[0].append((commit.raw_id, n_desc,))
         history.append(commits_group)
 
         symbolic_reference = self._symbolic_reference
 
         if c.rhodecode_repo.alias == 'svn':
             adjusted_f_path = self._adjust_file_path_for_svn(
                 f_path, c.rhodecode_repo)
             if adjusted_f_path != f_path:
                 log.debug(
                     'Recognized svn tag or branch in file "%s", using svn '
                     'specific symbolic references', f_path)
                 f_path = adjusted_f_path
                 symbolic_reference = self._symbolic_reference_svn
 
         branches = self._create_references(
             c.rhodecode_repo.branches, symbolic_reference, f_path)
         branches_group = (branches, _("Branches"))
 
         tags = self._create_references(
             c.rhodecode_repo.tags, symbolic_reference, f_path)
         tags_group = (tags, _("Tags"))
 
         history.append(branches_group)
         history.append(tags_group)
 
         return history, commits
 
     def _adjust_file_path_for_svn(self, f_path, repo):
         """
         Computes the relative path of `f_path`.
 
         This is mainly based on prefix matching of the recognized tags and
         branches in the underlying repository.
         """
         tags_and_branches = itertools.chain(
             repo.branches.iterkeys(),
             repo.tags.iterkeys())
         tags_and_branches = sorted(tags_and_branches, key=len, reverse=True)
 
         for name in tags_and_branches:
             if f_path.startswith(name + '/'):
                 f_path = vcspath.relpath(f_path, name)
                 break
         return f_path
 
     def _create_references(
             self, branches_or_tags, symbolic_reference, f_path):
         items = []
         for name, commit_id in branches_or_tags.items():
             sym_ref = symbolic_reference(commit_id, name, f_path)
             items.append((sym_ref, name))
         return items
 
     def _symbolic_reference(self, commit_id, name, f_path):
         return commit_id
 
     def _symbolic_reference_svn(self, commit_id, name, f_path):
         new_f_path = vcspath.join(name, f_path)
         return u'%s@%s' % (new_f_path, commit_id)
 
     @LoginRequired()
     @XHRRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @jsonify
     def nodelist(self, repo_name, revision, f_path):
         commit = self.__get_commit_or_redirect(revision, repo_name)
 
         metadata = self._get_nodelist_at_commit(
             repo_name, commit.raw_id, f_path)
         return {'nodes': metadata}
 
     @LoginRequired()
     @XHRRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     def nodetree_full(self, repo_name, commit_id, f_path):
         """
         Returns rendered html of file tree that contains commit date,
         author, revision for the specified combination of
         repo, commit_id and file path
 
         :param repo_name: name of the repository
         :param commit_id: commit_id of file tree
         :param f_path: file path of the requested directory
         """
 
         commit = self.__get_commit_or_redirect(commit_id, repo_name)
         try:
             dir_node = commit.get_node(f_path)
         except RepositoryError as e:
             return 'error {}'.format(safe_str(e))
 
         if dir_node.is_file():
             return ''
 
         c.file = dir_node
         c.commit = commit
 
         # using force=True here, make a little trick. We flush the cache and
         # compute it using the same key as without full_load, so the fully
         # loaded cached tree is now returned instead of partial
         return self._get_tree_at_commit(
             repo_name, commit.raw_id, dir_node.path, full_load=True,
             force=True)

rhodecode/lib/vcs/backends/base.py

@@ -1,1587 +1,1588 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2017 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/
 
 """
 Base module for all VCS systems
 """
 
 import collections
 import datetime
 import itertools
 import logging
 import os
 import time
 import warnings
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.lib.utils2 import safe_str, safe_unicode
 from rhodecode.lib.vcs import connection
 from rhodecode.lib.vcs.utils import author_name, author_email
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import (
     CommitError, EmptyRepositoryError, NodeAlreadyAddedError,
     NodeAlreadyChangedError, NodeAlreadyExistsError, NodeAlreadyRemovedError,
     NodeDoesNotExistError, NodeNotChangedError, VCSError,
     ImproperArchiveTypeError, BranchDoesNotExistError, CommitDoesNotExistError,
     RepositoryError)
 
 
 log = logging.getLogger(__name__)
 
 
 FILEMODE_DEFAULT = 0100644
 FILEMODE_EXECUTABLE = 0100755
 
 Reference = collections.namedtuple('Reference', ('type', 'name', 'commit_id'))
 MergeResponse = collections.namedtuple(
     'MergeResponse',
     ('possible', 'executed', 'merge_ref', 'failure_reason'))
 
 
 class MergeFailureReason(object):
     """
     Enumeration with all the reasons why the server side merge could fail.
 
     DO NOT change the number of the reasons, as they may be stored in the
     database.
 
     Changing the name of a reason is acceptable and encouraged to deprecate old
     reasons.
     """
 
     # Everything went well.
     NONE = 0
 
     # An unexpected exception was raised. Check the logs for more details.
     UNKNOWN = 1
 
     # The merge was not successful, there are conflicts.
     MERGE_FAILED = 2
 
     # The merge succeeded but we could not push it to the target repository.
     PUSH_FAILED = 3
 
     # The specified target is not a head in the target repository.
     TARGET_IS_NOT_HEAD = 4
 
     # The source repository contains more branches than the target. Pushing
     # the merge will create additional branches in the target.
     HG_SOURCE_HAS_MORE_BRANCHES = 5
 
     # The target reference has multiple heads. That does not allow to correctly
     # identify the target location. This could only happen for mercurial
     # branches.
     HG_TARGET_HAS_MULTIPLE_HEADS = 6
 
     # The target repository is locked
     TARGET_IS_LOCKED = 7
 
     # Deprecated, use MISSING_TARGET_REF or MISSING_SOURCE_REF instead.
     # A involved commit could not be found.
     _DEPRECATED_MISSING_COMMIT = 8
 
     # The target repo reference is missing.
     MISSING_TARGET_REF = 9
 
     # The source repo reference is missing.
     MISSING_SOURCE_REF = 10
 
     # The merge was not successful, there are conflicts related to sub
     # repositories.
     SUBREPO_MERGE_FAILED = 11
 
 
 class UpdateFailureReason(object):
     """
     Enumeration with all the reasons why the pull request update could fail.
 
     DO NOT change the number of the reasons, as they may be stored in the
     database.
 
     Changing the name of a reason is acceptable and encouraged to deprecate old
     reasons.
     """
 
     # Everything went well.
     NONE = 0
 
     # An unexpected exception was raised. Check the logs for more details.
     UNKNOWN = 1
 
     # The pull request is up to date.
     NO_CHANGE = 2
 
     # The pull request has a reference type that is not supported for update.
     WRONG_REF_TPYE = 3
 
     # Update failed because the target reference is missing.
     MISSING_TARGET_REF = 4
 
     # Update failed because the source reference is missing.
     MISSING_SOURCE_REF = 5
 
 
 class BaseRepository(object):
     """
     Base Repository for final backends
 
     .. attribute:: DEFAULT_BRANCH_NAME
 
        name of default branch (i.e. "trunk" for svn, "master" for git etc.
 
     .. attribute:: commit_ids
 
        list of all available commit ids, in ascending order
 
     .. attribute:: path
 
        absolute path to the repository
 
     .. attribute:: bookmarks
 
        Mapping from name to :term:`Commit ID` of the bookmark. Empty in case
        there are no bookmarks or the backend implementation does not support
        bookmarks.
 
     .. attribute:: tags
 
        Mapping from name to :term:`Commit ID` of the tag.
 
     """
 
     DEFAULT_BRANCH_NAME = None
     DEFAULT_CONTACT = u"Unknown"
     DEFAULT_DESCRIPTION = u"unknown"
     EMPTY_COMMIT_ID = '0' * 40
 
     path = None
 
     def __init__(self, repo_path, config=None, create=False, **kwargs):
         """
         Initializes repository. Raises RepositoryError if repository could
         not be find at the given ``repo_path`` or directory at ``repo_path``
         exists and ``create`` is set to True.
 
         :param repo_path: local path of the repository
         :param config: repository configuration
         :param create=False: if set to True, would try to create repository.
         :param src_url=None: if set, should be proper url from which repository
           would be cloned; requires ``create`` parameter to be set to True -
           raises RepositoryError if src_url is set and create evaluates to
           False
         """
         raise NotImplementedError
 
     def __repr__(self):
         return '<%s at %s>' % (self.__class__.__name__, self.path)
 
     def __len__(self):
         return self.count()
 
     def __eq__(self, other):
         same_instance = isinstance(other, self.__class__)
         return same_instance and other.path == self.path
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
     @LazyProperty
     def EMPTY_COMMIT(self):
         return EmptyCommit(self.EMPTY_COMMIT_ID)
 
     @LazyProperty
     def alias(self):
         for k, v in settings.BACKENDS.items():
             if v.split('.')[-1] == str(self.__class__.__name__):
                 return k
 
     @LazyProperty
     def name(self):
         return safe_unicode(os.path.basename(self.path))
 
     @LazyProperty
     def description(self):
         raise NotImplementedError
 
     def refs(self):
         """
         returns a `dict` with branches, bookmarks, tags, and closed_branches
         for this repository
         """
         return dict(
             branches=self.branches,
             branches_closed=self.branches_closed,
             tags=self.tags,
             bookmarks=self.bookmarks
         )
 
     @LazyProperty
     def branches(self):
         """
         A `dict` which maps branch names to commit ids.
         """
         raise NotImplementedError
 
     @LazyProperty
     def tags(self):
         """
         A `dict` which maps tags names to commit ids.
         """
         raise NotImplementedError
 
     @LazyProperty
     def size(self):
         """
         Returns combined size in bytes for all repository files
         """
         tip = self.get_commit()
         return tip.size
 
     def size_at_commit(self, commit_id):
         commit = self.get_commit(commit_id)
         return commit.size
 
     def is_empty(self):
         return not bool(self.commit_ids)
 
     @staticmethod
     def check_url(url, config):
         """
         Function will check given url and try to verify if it's a valid
         link.
         """
         raise NotImplementedError
 
     @staticmethod
     def is_valid_repository(path):
         """
         Check if given `path` contains a valid repository of this backend
         """
         raise NotImplementedError
 
     # ==========================================================================
     # COMMITS
     # ==========================================================================
 
     def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
         """
         Returns instance of `BaseCommit` class. If `commit_id` and `commit_idx`
         are both None, most recent commit is returned.
 
         :param pre_load: Optional. List of commit attributes to load.
 
         :raises ``EmptyRepositoryError``: if there are no commits
         """
         raise NotImplementedError
 
     def __iter__(self):
         for commit_id in self.commit_ids:
             yield self.get_commit(commit_id=commit_id)
 
     def get_commits(
             self, start_id=None, end_id=None, start_date=None, end_date=None,
             branch_name=None, pre_load=None):
         """
         Returns iterator of `BaseCommit` objects from start to end
         not inclusive. This should behave just like a list, ie. end is not
         inclusive.
 
         :param start_id: None or str, must be a valid commit id
         :param end_id: None or str, must be a valid commit id
         :param start_date:
         :param end_date:
         :param branch_name:
         :param pre_load:
         """
         raise NotImplementedError
 
     def __getitem__(self, key):
         """
         Allows index based access to the commit objects of this repository.
         """
         pre_load = ["author", "branch", "date", "message", "parents"]
         if isinstance(key, slice):
             return self._get_range(key, pre_load)
         return self.get_commit(commit_idx=key, pre_load=pre_load)
 
     def _get_range(self, slice_obj, pre_load):
         for commit_id in self.commit_ids.__getitem__(slice_obj):
             yield self.get_commit(commit_id=commit_id, pre_load=pre_load)
 
     def count(self):
         return len(self.commit_ids)
 
     def tag(self, name, user, commit_id=None, message=None, date=None, **opts):
         """
         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
         """
         raise NotImplementedError
 
     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
         """
         raise NotImplementedError
 
     def get_diff(
             self, commit1, commit2, path=None, 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 commit changes should be shown.
         :param path: Can be set to a path of a file to create a diff of that
           file. If `path1` is also set, this value is only associated to
           `commit2`.
         :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``.
         :param path1: Can be set to a path to associate with `commit1`. This
           parameter works only for backends which support diff generation for
           different paths. Other backends will raise a `ValueError` if `path1`
           is set and has a different value than `path`.
         :param file_path: filter this diff by given path pattern
         """
         raise NotImplementedError
 
     def strip(self, commit_id, branch=None):
         """
         Strip given commit_id from the repository
         """
         raise NotImplementedError
 
     def get_common_ancestor(self, commit_id1, commit_id2, repo2):
         """
         Return a latest common ancestor commit if one exists for this repo
         `commit_id1` vs `commit_id2` from `repo2`.
 
         :param commit_id1: Commit it from this repository to use as a
            target for the comparison.
         :param commit_id2: Source commit id to use for comparison.
         :param repo2: Source repository to use for comparison.
         """
         raise NotImplementedError
 
     def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
         """
         Compare this repository's revision `commit_id1` with `commit_id2`.
 
         Returns a tuple(commits, ancestor) that would be merged from
         `commit_id2`. Doing a normal compare (``merge=False``), ``None``
         will be returned as ancestor.
 
         :param commit_id1: Commit it from this repository to use as a
            target for the comparison.
         :param commit_id2: Source commit id to use for comparison.
         :param repo2: Source repository to use for comparison.
         :param merge: If set to ``True`` will do a merge compare which also
            returns the common ancestor.
         :param pre_load: Optional. List of commit attributes to load.
         """
         raise NotImplementedError
 
     def merge(self, target_ref, source_repo, source_ref, workspace_id,
               user_name='', user_email='', message='', dry_run=False,
               use_rebase=False):
         """
         Merge the revisions specified in `source_ref` from `source_repo`
         onto the `target_ref` of this repository.
 
         `source_ref` and `target_ref` are named tupls with the following
         fields `type`, `name` and `commit_id`.
 
         Returns a MergeResponse named tuple with the following fields
         'possible', 'executed', 'source_commit', 'target_commit',
         'merge_commit'.
 
         :param target_ref: `target_ref` points to the commit on top of which
             the `source_ref` should be merged.
         :param source_repo: The repository that contains the commits to be
             merged.
         :param source_ref: `source_ref` points to the topmost commit from
             the `source_repo` which should be merged.
         :param workspace_id: `workspace_id` unique identifier.
         :param user_name: Merge commit `user_name`.
         :param user_email: Merge commit `user_email`.
         :param message: Merge commit `message`.
         :param dry_run: If `True` the merge will not take place.
         :param use_rebase: If `True` commits from the source will be rebased
             on top of the target instead of being merged.
         """
         if dry_run:
             message = message or 'dry_run_merge_message'
             user_email = user_email or '[e-mail]'
             user_name = user_name or 'Dry-Run User'
         else:
             if not user_name:
                 raise ValueError('user_name cannot be empty')
             if not user_email:
                 raise ValueError('user_email cannot be empty')
             if not message:
                 raise ValueError('message cannot be empty')
 
         shadow_repository_path = self._maybe_prepare_merge_workspace(
             workspace_id, target_ref)
 
         try:
             return self._merge_repo(
                 shadow_repository_path, target_ref, source_repo,
                 source_ref, message, user_name, user_email, dry_run=dry_run,
                 use_rebase=use_rebase)
         except RepositoryError:
             log.exception(
                 'Unexpected failure when running merge, dry-run=%s',
                 dry_run)
             return MergeResponse(
                 False, False, None, MergeFailureReason.UNKNOWN)
 
     def _merge_repo(self, shadow_repository_path, target_ref,
                     source_repo, source_ref, merge_message,
                     merger_name, merger_email, dry_run=False, use_rebase=False):
         """Internal implementation of merge."""
         raise NotImplementedError
 
     def _maybe_prepare_merge_workspace(self, workspace_id, target_ref):
         """
         Create the merge workspace.
 
         :param workspace_id: `workspace_id` unique identifier.
         """
         raise NotImplementedError
 
     def cleanup_merge_workspace(self, workspace_id):
         """
         Remove merge workspace.
 
         This function MUST not fail in case there is no workspace associated to
         the given `workspace_id`.
 
         :param workspace_id: `workspace_id` unique identifier.
         """
         raise NotImplementedError
 
     # ========== #
     # COMMIT API #
     # ========== #
 
     @LazyProperty
     def in_memory_commit(self):
         """
         Returns :class:`InMemoryCommit` object for this repository.
         """
         raise NotImplementedError
 
     # ======================== #
     # UTILITIES FOR SUBCLASSES #
     # ======================== #
 
     def _validate_diff_commits(self, commit1, commit2):
         """
         Validates that the given commits are related to this repository.
 
         Intended as a utility for sub classes to have a consistent validation
         of input parameters in methods like :meth:`get_diff`.
         """
         self._validate_commit(commit1)
         self._validate_commit(commit2)
         if (isinstance(commit1, EmptyCommit) and
                 isinstance(commit2, EmptyCommit)):
             raise ValueError("Cannot compare two empty commits")
 
     def _validate_commit(self, commit):
         if not isinstance(commit, BaseCommit):
             raise TypeError(
                 "%s is not of type BaseCommit" % repr(commit))
         if commit.repository != self and not isinstance(commit, EmptyCommit):
             raise ValueError(
                 "Commit %s must be a valid commit from this repository %s, "
                 "related to this repository instead %s." %
                 (commit, self, commit.repository))
 
     def _validate_commit_id(self, commit_id):
         if not isinstance(commit_id, basestring):
             raise TypeError("commit_id must be a string value")
 
     def _validate_commit_idx(self, commit_idx):
         if not isinstance(commit_idx, (int, long)):
             raise TypeError("commit_idx must be a numeric value")
 
     def _validate_branch_name(self, branch_name):
         if branch_name and branch_name not in self.branches_all:
             msg = ("Branch %s not found in %s" % (branch_name, self))
             raise BranchDoesNotExistError(msg)
 
     #
     # Supporting deprecated API parts
     # TODO: johbo: consider to move this into a mixin
     #
 
     @property
     def EMPTY_CHANGESET(self):
         warnings.warn(
             "Use EMPTY_COMMIT or EMPTY_COMMIT_ID instead", DeprecationWarning)
         return self.EMPTY_COMMIT_ID
 
     @property
     def revisions(self):
         warnings.warn("Use commits attribute instead", DeprecationWarning)
         return self.commit_ids
 
     @revisions.setter
     def revisions(self, value):
         warnings.warn("Use commits attribute instead", DeprecationWarning)
         self.commit_ids = value
 
     def get_changeset(self, revision=None, pre_load=None):
         warnings.warn("Use get_commit instead", DeprecationWarning)
         commit_id = None
         commit_idx = None
         if isinstance(revision, basestring):
             commit_id = revision
         else:
             commit_idx = revision
         return self.get_commit(
             commit_id=commit_id, commit_idx=commit_idx, pre_load=pre_load)
 
     def get_changesets(
             self, start=None, end=None, start_date=None, end_date=None,
             branch_name=None, pre_load=None):
         warnings.warn("Use get_commits instead", DeprecationWarning)
         start_id = self._revision_to_commit(start)
         end_id = self._revision_to_commit(end)
         return self.get_commits(
             start_id=start_id, end_id=end_id, start_date=start_date,
             end_date=end_date, branch_name=branch_name, pre_load=pre_load)
 
     def _revision_to_commit(self, revision):
         """
         Translates a revision to a commit_id
 
         Helps to support the old changeset based API which allows to use
         commit ids and commit indices interchangeable.
         """
         if revision is None:
             return revision
 
         if isinstance(revision, basestring):
             commit_id = revision
         else:
             commit_id = self.commit_ids[revision]
         return commit_id
 
     @property
     def in_memory_changeset(self):
         warnings.warn("Use in_memory_commit instead", DeprecationWarning)
         return self.in_memory_commit
 
 
 class BaseCommit(object):
     """
     Each backend should implement it's commit representation.
 
     **Attributes**
 
         ``repository``
             repository object within which commit exists
 
         ``id``
             The commit id, may be ``raw_id`` or i.e. for mercurial's tip
             just ``tip``.
 
         ``raw_id``
             raw commit representation (i.e. full 40 length sha for git
             backend)
 
         ``short_id``
             shortened (if apply) version of ``raw_id``; it would be simple
             shortcut for ``raw_id[:12]`` for git/mercurial backends or same
             as ``raw_id`` for subversion
 
         ``idx``
             commit index
 
         ``files``
             list of ``FileNode`` (``Node`` with NodeKind.FILE) objects
 
         ``dirs``
             list of ``DirNode`` (``Node`` with NodeKind.DIR) objects
 
         ``nodes``
             combined list of ``Node`` objects
 
         ``author``
             author of the commit, as unicode
 
         ``message``
             message of the commit, as unicode
 
         ``parents``
             list of parent commits
 
     """
 
     branch = None
     """
     Depending on the backend this should be set to the branch name of the
     commit. Backends not supporting branches on commits should leave this
     value as ``None``.
     """
 
     _ARCHIVE_PREFIX_TEMPLATE = b'{repo_name}-{short_id}'
     """
     This template is used to generate a default prefix for repository archives
     if no prefix has been specified.
     """
 
     def __str__(self):
         return '<%s at %s:%s>' % (
             self.__class__.__name__, self.idx, self.short_id)
 
     def __repr__(self):
         return self.__str__()
 
     def __unicode__(self):
         return u'%s:%s' % (self.idx, self.short_id)
 
     def __eq__(self, other):
         same_instance = isinstance(other, self.__class__)
         return same_instance and self.raw_id == other.raw_id
 
     def __json__(self):
         parents = []
         try:
             for parent in self.parents:
                 parents.append({'raw_id': parent.raw_id})
         except NotImplementedError:
             # empty commit doesn't have parents implemented
             pass
 
         return {
             'short_id': self.short_id,
             'raw_id': self.raw_id,
             'revision': self.idx,
             'message': self.message,
             'date': self.date,
             'author': self.author,
             'parents': parents,
             'branch': self.branch
         }
 
     @LazyProperty
     def last(self):
         """
         ``True`` if this is last commit in repository, ``False``
         otherwise; trying to access this attribute while there is no
         commits would raise `EmptyRepositoryError`
         """
         if self.repository is None:
             raise CommitError("Cannot check if it's most recent commit")
         return self.raw_id == self.repository.commit_ids[-1]
 
     @LazyProperty
     def parents(self):
         """
         Returns list of parent commits.
         """
         raise NotImplementedError
 
     @property
     def merge(self):
         """
         Returns boolean if commit is a merge.
         """
         return len(self.parents) > 1
 
     @LazyProperty
     def children(self):
         """
         Returns list of child commits.
         """
         raise NotImplementedError
 
     @LazyProperty
     def id(self):
         """
         Returns string identifying this commit.
         """
         raise NotImplementedError
 
     @LazyProperty
     def raw_id(self):
         """
         Returns raw string identifying this commit.
         """
         raise NotImplementedError
 
     @LazyProperty
     def short_id(self):
         """
         Returns shortened version of ``raw_id`` attribute, as string,
         identifying this commit, useful for presentation to users.
         """
         raise NotImplementedError
 
     @LazyProperty
     def idx(self):
         """
         Returns integer identifying this commit.
         """
         raise NotImplementedError
 
     @LazyProperty
     def committer(self):
         """
         Returns committer for this commit
         """
         raise NotImplementedError
 
     @LazyProperty
     def committer_name(self):
         """
         Returns committer name for this commit
         """
 
         return author_name(self.committer)
 
     @LazyProperty
     def committer_email(self):
         """
         Returns committer email address for this commit
         """
 
         return author_email(self.committer)
 
     @LazyProperty
     def author(self):
         """
         Returns author for this commit
         """
 
         raise NotImplementedError
 
     @LazyProperty
     def author_name(self):
         """
         Returns author name for this commit
         """
 
         return author_name(self.author)
 
     @LazyProperty
     def author_email(self):
         """
         Returns author email address for this commit
         """
 
         return author_email(self.author)
 
     def get_file_mode(self, path):
         """
         Returns stat mode of the file at `path`.
         """
         raise NotImplementedError
 
     def is_link(self, path):
         """
         Returns ``True`` if given `path` is a symlink
         """
         raise NotImplementedError
 
     def get_file_content(self, path):
         """
         Returns content of the file at the given `path`.
         """
         raise NotImplementedError
 
     def get_file_size(self, path):
         """
         Returns size of the file at the given `path`.
         """
         raise NotImplementedError
 
     def get_file_commit(self, path, pre_load=None):
         """
         Returns last commit of the file at the given `path`.
 
         :param pre_load: Optional. List of commit attributes to load.
         """
         commits = self.get_file_history(path, limit=1, pre_load=pre_load)
         if not commits:
             raise RepositoryError(
                 'Failed to fetch history for path {}. '
                 'Please check if such path exists in your repository'.format(
                     path))
         return commits[0]
 
     def get_file_history(self, path, limit=None, pre_load=None):
         """
         Returns history of file as reversed list of :class:`BaseCommit`
         objects for which file at given `path` has been modified.
 
         :param limit: Optional. Allows to limit the size of the returned
            history. This is intended as a hint to the underlying backend, so
            that it can apply optimizations depending on the limit.
         :param pre_load: Optional. List of commit attributes to load.
         """
         raise NotImplementedError
 
     def get_file_annotate(self, path, pre_load=None):
         """
         Returns a generator of four element tuples with
         lineno, sha, commit lazy loader and line
 
         :param pre_load: Optional. List of commit attributes to load.
         """
         raise NotImplementedError
 
     def get_nodes(self, path):
         """
         Returns combined ``DirNode`` and ``FileNode`` objects list representing
         state of commit at the given ``path``.
 
         :raises ``CommitError``: if node at the given ``path`` is not
           instance of ``DirNode``
         """
         raise NotImplementedError
 
     def get_node(self, path):
         """
         Returns ``Node`` object from the given ``path``.
 
         :raises ``NodeDoesNotExistError``: if there is no node at the given
           ``path``
         """
         raise NotImplementedError
 
     def get_largefile_node(self, path):
         """
-        Returns the path to largefile from Mercurial storage.
+        Returns the path to largefile from Mercurial/Git-lfs storage.
+        or None if it's not a largefile node
         """
-        raise NotImplementedError
+        return None
 
     def archive_repo(self, file_path, kind='tgz', subrepos=None,
                      prefix=None, write_metadata=False, mtime=None):
         """
         Creates an archive containing the contents of the repository.
 
         :param file_path: path to the file which to create the archive.
         :param kind: one of following: ``"tbz2"``, ``"tgz"``, ``"zip"``.
         :param prefix: name of root directory in archive.
             Default is repository name and commit's short_id joined with dash:
             ``"{repo_name}-{short_id}"``.
         :param write_metadata: write a metadata file into archive.
         :param mtime: custom modification time for archive creation, defaults
             to time.time() if not given.
 
         :raise VCSError: If prefix has a problem.
         """
         allowed_kinds = settings.ARCHIVE_SPECS.keys()
         if kind not in allowed_kinds:
             raise ImproperArchiveTypeError(
                 'Archive kind (%s) not supported use one of %s' %
                 (kind, allowed_kinds))
 
         prefix = self._validate_archive_prefix(prefix)
 
         mtime = mtime or time.mktime(self.date.timetuple())
 
         file_info = []
         cur_rev = self.repository.get_commit(commit_id=self.raw_id)
         for _r, _d, files in cur_rev.walk('/'):
             for f in files:
                 f_path = os.path.join(prefix, f.path)
                 file_info.append(
                     (f_path, f.mode, f.is_link(), f.raw_bytes))
 
         if write_metadata:
             metadata = [
                 ('repo_name', self.repository.name),
                 ('rev', self.raw_id),
                 ('create_time', mtime),
                 ('branch', self.branch),
                 ('tags', ','.join(self.tags)),
             ]
             meta = ["%s:%s" % (f_name, value) for f_name, value in metadata]
             file_info.append(('.archival.txt', 0644, False, '\n'.join(meta)))
 
         connection.Hg.archive_repo(file_path, mtime, file_info, kind)
 
     def _validate_archive_prefix(self, prefix):
         if prefix is None:
             prefix = self._ARCHIVE_PREFIX_TEMPLATE.format(
                 repo_name=safe_str(self.repository.name),
                 short_id=self.short_id)
         elif not isinstance(prefix, str):
             raise ValueError("prefix not a bytes object: %s" % repr(prefix))
         elif prefix.startswith('/'):
             raise VCSError("Prefix cannot start with leading slash")
         elif prefix.strip() == '':
             raise VCSError("Prefix cannot be empty")
         return prefix
 
     @LazyProperty
     def root(self):
         """
         Returns ``RootNode`` object for this commit.
         """
         return self.get_node('')
 
     def next(self, branch=None):
         """
         Returns next commit from current, if branch is gives it will return
         next commit belonging to this branch
 
         :param branch: show commits within the given named branch
         """
         indexes = xrange(self.idx + 1, self.repository.count())
         return self._find_next(indexes, branch)
 
     def prev(self, branch=None):
         """
         Returns previous commit from current, if branch is gives it will
         return previous commit belonging to this branch
 
         :param branch: show commit within the given named branch
         """
         indexes = xrange(self.idx - 1, -1, -1)
         return self._find_next(indexes, branch)
 
     def _find_next(self, indexes, branch=None):
         if branch and self.branch != branch:
             raise VCSError('Branch option used on commit not belonging '
                            'to that branch')
 
         for next_idx in indexes:
             commit = self.repository.get_commit(commit_idx=next_idx)
             if branch and branch != commit.branch:
                 continue
             return commit
         raise CommitDoesNotExistError
 
     def diff(self, ignore_whitespace=True, context=3):
         """
         Returns a `Diff` object representing the change made by this commit.
         """
         parent = (
             self.parents[0] if self.parents else self.repository.EMPTY_COMMIT)
         diff = self.repository.get_diff(
             parent, self,
             ignore_whitespace=ignore_whitespace,
             context=context)
         return diff
 
     @LazyProperty
     def added(self):
         """
         Returns list of added ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def changed(self):
         """
         Returns list of modified ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def removed(self):
         """
         Returns list of removed ``FileNode`` objects.
         """
         raise NotImplementedError
 
     @LazyProperty
     def size(self):
         """
         Returns total number of bytes from contents of all filenodes.
         """
         return sum((node.size for node in self.get_filenodes_generator()))
 
     def walk(self, topurl=''):
         """
         Similar to os.walk method. Insted of filesystem it walks through
         commit starting at given ``topurl``.  Returns generator of tuples
         (topnode, dirnodes, filenodes).
         """
         topnode = self.get_node(topurl)
         if not topnode.is_dir():
             return
         yield (topnode, topnode.dirs, topnode.files)
         for dirnode in topnode.dirs:
             for tup in self.walk(dirnode.path):
                 yield tup
 
     def get_filenodes_generator(self):
         """
         Returns generator that yields *all* file nodes.
         """
         for topnode, dirs, files in self.walk():
             for node in files:
                 yield node
 
     #
     # Utilities for sub classes to support consistent behavior
     #
 
     def no_node_at_path(self, path):
         return NodeDoesNotExistError(
             "There is no file nor directory at the given path: "
             "'%s' at commit %s" % (path, self.short_id))
 
     def _fix_path(self, path):
         """
         Paths are stored without trailing slash so we need to get rid off it if
         needed.
         """
         return path.rstrip('/')
 
     #
     # Deprecated API based on changesets
     #
 
     @property
     def revision(self):
         warnings.warn("Use idx instead", DeprecationWarning)
         return self.idx
 
     @revision.setter
     def revision(self, value):
         warnings.warn("Use idx instead", DeprecationWarning)
         self.idx = value
 
     def get_file_changeset(self, path):
         warnings.warn("Use get_file_commit instead", DeprecationWarning)
         return self.get_file_commit(path)
 
 
 class BaseChangesetClass(type):
 
     def __instancecheck__(self, instance):
         return isinstance(instance, BaseCommit)
 
 
 class BaseChangeset(BaseCommit):
 
     __metaclass__ = BaseChangesetClass
 
     def __new__(cls, *args, **kwargs):
         warnings.warn(
             "Use BaseCommit instead of BaseChangeset", DeprecationWarning)
         return super(BaseChangeset, cls).__new__(cls, *args, **kwargs)
 
 
 class BaseInMemoryCommit(object):
     """
     Represents differences between repository's state (most recent head) and
     changes made *in place*.
 
     **Attributes**
 
         ``repository``
             repository object for this in-memory-commit
 
         ``added``
             list of ``FileNode`` objects marked as *added*
 
         ``changed``
             list of ``FileNode`` objects marked as *changed*
 
         ``removed``
             list of ``FileNode`` or ``RemovedFileNode`` objects marked to be
             *removed*
 
         ``parents``
             list of :class:`BaseCommit` instances representing parents of
             in-memory commit. Should always be 2-element sequence.
 
     """
 
     def __init__(self, repository):
         self.repository = repository
         self.added = []
         self.changed = []
         self.removed = []
         self.parents = []
 
     def add(self, *filenodes):
         """
         Marks given ``FileNode`` objects as *to be committed*.
 
         :raises ``NodeAlreadyExistsError``: if node with same path exists at
            latest commit
         :raises ``NodeAlreadyAddedError``: if node with same path is already
            marked as *added*
         """
         # Check if not already marked as *added* first
         for node in filenodes:
             if node.path in (n.path for n in self.added):
                 raise NodeAlreadyAddedError(
                     "Such FileNode %s is already marked for addition"
                     % node.path)
         for node in filenodes:
             self.added.append(node)
 
     def change(self, *filenodes):
         """
         Marks given ``FileNode`` objects to be *changed* in next commit.
 
         :raises ``EmptyRepositoryError``: if there are no commits yet
         :raises ``NodeAlreadyExistsError``: if node with same path is already
            marked to be *changed*
         :raises ``NodeAlreadyRemovedError``: if node with same path is already
            marked to be *removed*
         :raises ``NodeDoesNotExistError``: if node doesn't exist in latest
            commit
         :raises ``NodeNotChangedError``: if node hasn't really be changed
         """
         for node in filenodes:
             if node.path in (n.path for n in self.removed):
                 raise NodeAlreadyRemovedError(
                     "Node at %s is already marked as removed" % node.path)
         try:
             self.repository.get_commit()
         except EmptyRepositoryError:
             raise EmptyRepositoryError(
                 "Nothing to change - try to *add* new nodes rather than "
                 "changing them")
         for node in filenodes:
             if node.path in (n.path for n in self.changed):
                 raise NodeAlreadyChangedError(
                     "Node at '%s' is already marked as changed" % node.path)
             self.changed.append(node)
 
     def remove(self, *filenodes):
         """
         Marks given ``FileNode`` (or ``RemovedFileNode``) objects to be
         *removed* in next commit.
 
         :raises ``NodeAlreadyRemovedError``: if node has been already marked to
            be *removed*
         :raises ``NodeAlreadyChangedError``: if node has been already marked to
            be *changed*
         """
         for node in filenodes:
             if node.path in (n.path for n in self.removed):
                 raise NodeAlreadyRemovedError(
                     "Node is already marked to for removal at %s" % node.path)
             if node.path in (n.path for n in self.changed):
                 raise NodeAlreadyChangedError(
                     "Node is already marked to be changed at %s" % node.path)
             # We only mark node as *removed* - real removal is done by
             # commit method
             self.removed.append(node)
 
     def reset(self):
         """
         Resets this instance to initial state (cleans ``added``, ``changed``
         and ``removed`` lists).
         """
         self.added = []
         self.changed = []
         self.removed = []
         self.parents = []
 
     def get_ipaths(self):
         """
         Returns generator of paths from nodes marked as added, changed or
         removed.
         """
         for node in itertools.chain(self.added, self.changed, self.removed):
             yield node.path
 
     def get_paths(self):
         """
         Returns list of paths from nodes marked as added, changed or removed.
         """
         return list(self.get_ipaths())
 
     def check_integrity(self, parents=None):
         """
         Checks in-memory commit's integrity. Also, sets parents if not
         already set.
 
         :raises CommitError: if any error occurs (i.e.
           ``NodeDoesNotExistError``).
         """
         if not self.parents:
             parents = parents or []
             if len(parents) == 0:
                 try:
                     parents = [self.repository.get_commit(), None]
                 except EmptyRepositoryError:
                     parents = [None, None]
             elif len(parents) == 1:
                 parents += [None]
             self.parents = parents
 
         # Local parents, only if not None
         parents = [p for p in self.parents if p]
 
         # Check nodes marked as added
         for p in parents:
             for node in self.added:
                 try:
                     p.get_node(node.path)
                 except NodeDoesNotExistError:
                     pass
                 else:
                     raise NodeAlreadyExistsError(
                         "Node `%s` already exists at %s" % (node.path, p))
 
         # Check nodes marked as changed
         missing = set(self.changed)
         not_changed = set(self.changed)
         if self.changed and not parents:
             raise NodeDoesNotExistError(str(self.changed[0].path))
         for p in parents:
             for node in self.changed:
                 try:
                     old = p.get_node(node.path)
                     missing.remove(node)
                     # if content actually changed, remove node from not_changed
                     if old.content != node.content:
                         not_changed.remove(node)
                 except NodeDoesNotExistError:
                     pass
         if self.changed and missing:
             raise NodeDoesNotExistError(
                 "Node `%s` marked as modified but missing in parents: %s"
                 % (node.path, parents))
 
         if self.changed and not_changed:
             raise NodeNotChangedError(
                 "Node `%s` wasn't actually changed (parents: %s)"
                 % (not_changed.pop().path, parents))
 
         # Check nodes marked as removed
         if self.removed and not parents:
             raise NodeDoesNotExistError(
                 "Cannot remove node at %s as there "
                 "were no parents specified" % self.removed[0].path)
         really_removed = set()
         for p in parents:
             for node in self.removed:
                 try:
                     p.get_node(node.path)
                     really_removed.add(node)
                 except CommitError:
                     pass
         not_removed = set(self.removed) - really_removed
         if not_removed:
             # TODO: johbo: This code branch does not seem to be covered
             raise NodeDoesNotExistError(
                 "Cannot remove node at %s from "
                 "following parents: %s" % (not_removed, parents))
 
     def commit(
             self, message, author, parents=None, branch=None, date=None,
             **kwargs):
         """
         Performs in-memory commit (doesn't check workdir in any way) and
         returns newly created :class:`BaseCommit`. Updates repository's
         attribute `commits`.
 
         .. note::
 
            While overriding this method each backend's should call
            ``self.check_integrity(parents)`` in the first place.
 
         :param message: message of the commit
         :param author: full username, i.e. "Joe Doe <[e-mail]>"
         :param parents: single parent or sequence of parents from which commit
            would be derived
         :param date: ``datetime.datetime`` instance. Defaults to
            ``datetime.datetime.now()``.
         :param branch: branch name, as string. If none given, default backend's
            branch would be used.
 
         :raises ``CommitError``: if any error occurs while committing
         """
         raise NotImplementedError
 
 
 class BaseInMemoryChangesetClass(type):
 
     def __instancecheck__(self, instance):
         return isinstance(instance, BaseInMemoryCommit)
 
 
 class BaseInMemoryChangeset(BaseInMemoryCommit):
 
     __metaclass__ = BaseInMemoryChangesetClass
 
     def __new__(cls, *args, **kwargs):
         warnings.warn(
             "Use BaseCommit instead of BaseInMemoryCommit", DeprecationWarning)
         return super(BaseInMemoryChangeset, cls).__new__(cls, *args, **kwargs)
 
 
 class EmptyCommit(BaseCommit):
     """
     An dummy empty commit. It's possible to pass hash when creating
     an EmptyCommit
     """
 
     def __init__(
             self, commit_id='0' * 40, repo=None, alias=None, idx=-1,
             message='', author='', date=None):
         self._empty_commit_id = commit_id
         # TODO: johbo: Solve idx parameter, default value does not make
         # too much sense
         self.idx = idx
         self.message = message
         self.author = author
         self.date = date or datetime.datetime.fromtimestamp(0)
         self.repository = repo
         self.alias = alias
 
     @LazyProperty
     def raw_id(self):
         """
         Returns raw string identifying this commit, useful for web
         representation.
         """
 
         return self._empty_commit_id
 
     @LazyProperty
     def branch(self):
         if self.alias:
             from rhodecode.lib.vcs.backends import get_backend
             return get_backend(self.alias).DEFAULT_BRANCH_NAME
 
     @LazyProperty
     def short_id(self):
         return self.raw_id[:12]
 
     @LazyProperty
     def id(self):
         return self.raw_id
 
     def get_file_commit(self, path):
         return self
 
     def get_file_content(self, path):
         return u''
 
     def get_file_size(self, path):
         return 0
 
 
 class EmptyChangesetClass(type):
 
     def __instancecheck__(self, instance):
         return isinstance(instance, EmptyCommit)
 
 
 class EmptyChangeset(EmptyCommit):
 
     __metaclass__ = EmptyChangesetClass
 
     def __new__(cls, *args, **kwargs):
         warnings.warn(
             "Use EmptyCommit instead of EmptyChangeset", DeprecationWarning)
         return super(EmptyCommit, cls).__new__(cls, *args, **kwargs)
 
     def __init__(self, cs='0' * 40, repo=None, requested_revision=None,
                  alias=None, revision=-1, message='', author='', date=None):
         if requested_revision is not None:
             warnings.warn(
                 "Parameter requested_revision not supported anymore",
                 DeprecationWarning)
         super(EmptyChangeset, self).__init__(
             commit_id=cs, repo=repo, alias=alias, idx=revision,
             message=message, author=author, date=date)
 
         @property
         def revision(self):
             warnings.warn("Use idx instead", DeprecationWarning)
             return self.idx
 
         @revision.setter
         def revision(self, value):
             warnings.warn("Use idx instead", DeprecationWarning)
             self.idx = value
 
 
 class EmptyRepository(BaseRepository):
     def __init__(self, repo_path=None, config=None, create=False, **kwargs):
         pass
 
     def get_diff(self, *args, **kwargs):
         from rhodecode.lib.vcs.backends.git.diff import GitDiff
         return GitDiff('')
 
 
 class CollectionGenerator(object):
 
     def __init__(self, repo, commit_ids, collection_size=None, pre_load=None):
         self.repo = repo
         self.commit_ids = commit_ids
         # TODO: (oliver) this isn't currently hooked up
         self.collection_size = None
         self.pre_load = pre_load
 
     def __len__(self):
         if self.collection_size is not None:
             return self.collection_size
         return self.commit_ids.__len__()
 
     def __iter__(self):
         for commit_id in self.commit_ids:
             # TODO: johbo: Mercurial passes in commit indices or commit ids
             yield self._commit_factory(commit_id)
 
     def _commit_factory(self, commit_id):
         """
         Allows backends to override the way commits are generated.
         """
         return self.repo.get_commit(commit_id=commit_id,
                                     pre_load=self.pre_load)
 
     def __getslice__(self, i, j):
         """
         Returns an iterator of sliced repository
         """
         commit_ids = self.commit_ids[i:j]
         return self.__class__(
             self.repo, commit_ids, pre_load=self.pre_load)
 
     def __repr__(self):
         return '<CollectionGenerator[len:%s]>' % (self.__len__())
 
 
 class Config(object):
     """
     Represents the configuration for a repository.
 
     The API is inspired by :class:`ConfigParser.ConfigParser` from the
     standard library. It implements only the needed subset.
     """
 
     def __init__(self):
         self._values = {}
 
     def copy(self):
         clone = Config()
         for section, values in self._values.items():
             clone._values[section] = values.copy()
         return clone
 
     def __repr__(self):
         return '<Config(%s sections) at %s>' % (
             len(self._values), hex(id(self)))
 
     def items(self, section):
         return self._values.get(section, {}).iteritems()
 
     def get(self, section, option):
         return self._values.get(section, {}).get(option)
 
     def set(self, section, option, value):
         section_values = self._values.setdefault(section, {})
         section_values[option] = value
 
     def clear_section(self, section):
         self._values[section] = {}
 
     def serialize(self):
         """
         Creates a list of three tuples (section, key, value) representing
         this config object.
         """
         items = []
         for section in self._values:
             for option, value in self._values[section].items():
                 items.append(
                     (safe_str(section), safe_str(option), safe_str(value)))
         return items
 
 
 class Diff(object):
     """
     Represents a diff result from a repository backend.
 
     Subclasses have to provide a backend specific value for
     :attr:`_header_re` and :attr:`_meta_re`.
     """
     _meta_re = None
     _header_re = None
 
     def __init__(self, raw_diff):
         self.raw = raw_diff
 
     def chunks(self):
         """
         split the diff in chunks of separate --git a/file b/file chunks
         to make diffs consistent we must prepend with \n, and make sure
         we can detect last chunk as this was also has special rule
         """
 
         diff_parts = ('\n' + self.raw).split('\ndiff --git')
         header = diff_parts[0]
 
         if self._meta_re:
             match = self._meta_re.match(header)
 
         chunks = diff_parts[1:]
         total_chunks = len(chunks)
 
         return (
             DiffChunk(chunk, self, cur_chunk == total_chunks)
             for cur_chunk, chunk in enumerate(chunks, start=1))
 
 
 class DiffChunk(object):
 
     def __init__(self, chunk, diff, last_chunk):
         self._diff = diff
 
         # since we split by \ndiff --git that part is lost from original diff
         # we need to re-apply it at the end, EXCEPT ! if it's last chunk
         if not last_chunk:
             chunk += '\n'
 
         match = self._diff._header_re.match(chunk)
         self.header = match.groupdict()
         self.diff = chunk[match.end():]
         self.raw = chunk

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

@@ -1,527 +1,538 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2017 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 ConfigParser import ConfigParser
 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)
+    RemovedFileNodesGenerator, LargeFileNode)
 
 
 class GitCommit(base.BaseCommit):
     """
     Represents state of the repository at single commit id.
     """
     _author_property = 'author'
     _committer_property = 'committer'
     _date_property = 'commit_time'
     _date_tz_property = 'commit_timezone'
     _message_property = 'message'
     _parents_property = 'parents'
 
     _filter_pre_load = [
         # done through a more complex tree walk on parents
         "affected_files",
         # based on repository cached property
         "branch",
         # 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",
     ]
 
     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)
             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.commit_attribute(self.id, self._message_property))
 
     @LazyProperty
     def committer(self):
         return safe_unicode(
             self._remote.commit_attribute(self.id, self._committer_property))
 
     @LazyProperty
     def author(self):
         return safe_unicode(
             self._remote.commit_attribute(self.id, self._author_property))
 
     @LazyProperty
     def date(self):
         unix_ts, tz = self._remote.get_object_attrs(
             self.raw_id, self._date_property, self._date_tz_property)
         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 branch(self):
         for name, commit_id in self.repository.branches.iteritems():
             if commit_id == self.raw_id:
                 return safe_unicode(name)
         return None
 
     def _get_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
 
         parts = path.split('/')
         dirs, name = parts[:-1], parts[-1]
         cur_dir = ''
 
         # initially extract things from root dir
         tree_items = self._remote.tree_items(tree_id)
         self._process_tree_items(tree_items, cur_dir)
 
         for dir in dirs:
             if cur_dir:
                 cur_dir = '/'.join((cur_dir, dir))
             else:
                 cur_dir = dir
             dir_id = None
             for item, stat_, id_, type_ in tree_items:
                 if item == dir:
                     dir_id = id_
                     break
             if dir_id:
                 if type_ != "tree":
                     raise CommitError('%s is not a directory' % cur_dir)
                 # update tree
                 tree_items = self._remote.tree_items(dir_id)
             else:
                 raise CommitError('%s have not been found' % cur_dir)
 
             # cache all items from the given traversed tree
             self._process_tree_items(tree_items, cur_dir)
 
         if path not in self._paths:
             raise self.no_node_at_path(path)
 
         return self._paths[path]
 
     def _process_tree_items(self, items, cur_dir):
         for item, stat_, id_, type_ in items:
             if cur_dir:
                 name = '/'.join((cur_dir, item))
             else:
                 name = item
             self._paths[name] = [id_, type_]
             self._stat_modes[name] = stat_
 
     def _get_kind(self, path):
         path_id, type_ = self._get_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.commit_attribute(
             self.id, self._parents_property)
         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)
 
     def _make_commits(self, commit_ids):
         return [self.repository.get_commit(commit_id=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_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`.
         """
         id_, _ = self._get_id_for_path(path)
         return self._remote.blob_as_pretty_string(id_)
 
     def get_file_size(self, path):
         """
         Returns size of the file at given `path`.
         """
         id_, _ = self._get_id_for_path(path)
         return self._remote.blob_raw_length(id_)
 
     def get_file_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)
 
         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)
 
         return [
             self.repository.get_commit(commit_id=commit_id, pre_load=pre_load)
             for commit_id in commit_ids]
 
     # TODO: unused for now potential replacement for subprocess
     def get_file_history_2(self, path, limit=None, pre_load=None):
         """
         Returns history of file as reversed list of `Commit` objects for
         which file at given `path` has been modified.
         """
         self._get_filectx(path)
         f_path = safe_str(path)
 
         commit_ids = self._remote.get_file_history(f_path, self.id, limit)
 
         return [
             self.repository.get_commit(commit_id=commit_id, pre_load=pre_load)
             for commit_id in commit_ids]
 
     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)
 
         for i, blame_line in enumerate(output.split('\n')[:-1]):
             line_no = i + 1
             commit_id, line = re.split(r' ', blame_line, 1)
             yield (
                 line_no, commit_id,
                 lambda: self.repository.get_commit(commit_id=commit_id,
                                                    pre_load=pre_load),
                 line)
 
     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)
         id_, _ = self._get_id_for_path(path)
         tree_id = self._remote[id_]['id']
         dirnodes = []
         filenodes = []
         alias = self.repository.alias
         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=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:
                 id_, type_ = self._get_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=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)
             else:
                 raise self.no_node_at_path(path)
 
             # cache node
             self.nodes[path] = node
         return self.nodes[path]
 
+    def get_largefile_node(self, path):
+        id_, _ = self._get_id_for_path(path)
+        pointer_spec = self._remote.is_large_file(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()
             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/hg/commit.py

@@ -1,362 +1,362 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2017 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 = repository._sanitize_commit_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.idx, 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)
             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.idx))
 
     @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.idx))
 
     @LazyProperty
     def committer(self):
         return safe_unicode(self.author)
 
     @LazyProperty
     def author(self):
         return safe_unicode(self._remote.ctx_user(self.idx))
 
     @LazyProperty
     def date(self):
         return utcdate_fromtimestamp(*self._remote.ctx_date(self.idx))
 
     @LazyProperty
     def status(self):
         """
         Returns modified, added, removed, deleted files for current commit
         """
         return self._remote.ctx_status(self.idx)
 
     @LazyProperty
     def _file_paths(self):
         return self._remote.ctx_list(self.idx)
 
     @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):
         return [self.repository.get_commit(commit_idx=idx)
                 for idx in indexes if idx >= 0]
 
     @LazyProperty
     def parents(self):
         """
         Returns list of parent commits.
         """
         parents = self._remote.ctx_parents(self.idx)
         return self._make_commits(parents)
 
     @LazyProperty
     def children(self):
         """
         Returns list of child commits.
         """
         children = self._remote.ctx_children(self.idx)
         return self._make_commits(children)
 
     def diff(self, ignore_whitespace=True, context=3):
         result = self._remote.ctx_diff(
             self.idx,
             git=True, ignore_whitespace=ignore_whitespace, context=context)
         diff = ''.join(result)
         return MercurialDiff(diff)
 
     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.idx, 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.idx, path)
 
     def get_file_content(self, path):
         """
         Returns content of the file at given ``path``.
         """
         path = self._get_filectx(path)
         return self._remote.fctx_data(self.idx, 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.idx, path)
 
     def get_file_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.file_history(self.idx, 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.idx, 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),
                 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.idx, 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():
             loc = vals[0]
             commit = vals[1]
             dirnodes.append(
                 SubModuleNode(k, url=loc, commit=commit, alias=alias))
         nodes = dirnodes + filenodes
         # cache nodes
         for node in 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):
-        path = os.path.join(LARGEFILE_PREFIX, 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_store(file_id):
-                path = self._remote.store_path(file_id)
-                return LargeFileNode(path, commit=self)
+
+            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):
-                path = self._remote.store_path(file_id)
+                lf_path = self._remote.store_path(file_id)
                 self._remote.link(file_id, path)
-                return LargeFileNode(path, commit=self)
+                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.idx)
 
     @LazyProperty
     def affected_files(self):
         """
         Gets a fast accessible file changes for given commit
         """
         return self._remote.ctx_files(self.idx)
 
     @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/lib/vcs/nodes.py

@@ -1,779 +1,800 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2017 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/
 
 """
 Module holding everything related to vcs nodes, with vcs2 architecture.
 """
 
-
+import os
 import stat
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.config.conf import LANGUAGES_EXTENSIONS_MAP
 from rhodecode.lib.utils import safe_unicode, safe_str
 from rhodecode.lib.utils2 import md5
 from rhodecode.lib.vcs import path as vcspath
 from rhodecode.lib.vcs.backends.base import EmptyCommit, FILEMODE_DEFAULT
 from rhodecode.lib.vcs.conf.mtypes import get_mimetypes_db
 from rhodecode.lib.vcs.exceptions import NodeError, RemovedFileNodeError
 
 LARGEFILE_PREFIX = '.hglf'
 
 
 class NodeKind:
     SUBMODULE = -1
     DIR = 1
     FILE = 2
     LARGEFILE = 3
 
 
 class NodeState:
     ADDED = u'added'
     CHANGED = u'changed'
     NOT_CHANGED = u'not changed'
     REMOVED = u'removed'
 
 
 class NodeGeneratorBase(object):
     """
     Base class for removed added and changed filenodes, it's a lazy generator
     class that will create filenodes only on iteration or call
 
     The len method doesn't need to create filenodes at all
     """
 
     def __init__(self, current_paths, cs):
         self.cs = cs
         self.current_paths = current_paths
 
     def __call__(self):
         return [n for n in self]
 
     def __getslice__(self, i, j):
         for p in self.current_paths[i:j]:
             yield self.cs.get_node(p)
 
     def __len__(self):
         return len(self.current_paths)
 
     def __iter__(self):
         for p in self.current_paths:
             yield self.cs.get_node(p)
 
 
 class AddedFileNodesGenerator(NodeGeneratorBase):
     """
     Class holding added files for current commit
     """
 
 
 class ChangedFileNodesGenerator(NodeGeneratorBase):
     """
     Class holding changed files for current commit
     """
 
 
 class RemovedFileNodesGenerator(NodeGeneratorBase):
     """
     Class holding removed files for current commit
     """
     def __iter__(self):
         for p in self.current_paths:
             yield RemovedFileNode(path=p)
 
     def __getslice__(self, i, j):
         for p in self.current_paths[i:j]:
             yield RemovedFileNode(path=p)
 
 
 class Node(object):
     """
     Simplest class representing file or directory on repository.  SCM backends
     should use ``FileNode`` and ``DirNode`` subclasses rather than ``Node``
     directly.
 
     Node's ``path`` cannot start with slash as we operate on *relative* paths
     only. Moreover, every single node is identified by the ``path`` attribute,
     so it cannot end with slash, too. Otherwise, path could lead to mistakes.
     """
 
     commit = None
 
     def __init__(self, path, kind):
         self._validate_path(path)  # can throw exception if path is invalid
         self.path = safe_str(path.rstrip('/'))  # we store paths as str
         if path == '' and kind != NodeKind.DIR:
             raise NodeError("Only DirNode and its subclasses may be "
                             "initialized with empty path")
         self.kind = kind
 
         if self.is_root() and not self.is_dir():
             raise NodeError("Root node cannot be FILE kind")
 
     def _validate_path(self, path):
         if path.startswith('/'):
             raise NodeError(
                 "Cannot initialize Node objects with slash at "
                 "the beginning as only relative paths are supported. "
                 "Got %s" % (path,))
 
     @LazyProperty
     def parent(self):
         parent_path = self.get_parent_path()
         if parent_path:
             if self.commit:
                 return self.commit.get_node(parent_path)
             return DirNode(parent_path)
         return None
 
     @LazyProperty
     def unicode_path(self):
         return safe_unicode(self.path)
 
     @LazyProperty
     def dir_path(self):
         """
         Returns name of the directory from full path of this vcs node. Empty
         string is returned if there's no directory in the path
         """
         _parts = self.path.rstrip('/').rsplit('/', 1)
         if len(_parts) == 2:
             return safe_unicode(_parts[0])
         return u''
 
     @LazyProperty
     def name(self):
         """
         Returns name of the node so if its path
         then only last part is returned.
         """
         return safe_unicode(self.path.rstrip('/').split('/')[-1])
 
     @property
     def kind(self):
         return self._kind
 
     @kind.setter
     def kind(self, kind):
         if hasattr(self, '_kind'):
             raise NodeError("Cannot change node's kind")
         else:
             self._kind = kind
             # Post setter check (path's trailing slash)
             if self.path.endswith('/'):
                 raise NodeError("Node's path cannot end with slash")
 
     def __cmp__(self, other):
         """
         Comparator using name of the node, needed for quick list sorting.
         """
         kind_cmp = cmp(self.kind, other.kind)
         if kind_cmp:
             return kind_cmp
         return cmp(self.name, other.name)
 
     def __eq__(self, other):
         for attr in ['name', 'path', 'kind']:
             if getattr(self, attr) != getattr(other, attr):
                 return False
         if self.is_file():
             if self.content != other.content:
                 return False
         else:
             # For DirNode's check without entering each dir
             self_nodes_paths = list(sorted(n.path for n in self.nodes))
             other_nodes_paths = list(sorted(n.path for n in self.nodes))
             if self_nodes_paths != other_nodes_paths:
                 return False
         return True
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
     def __repr__(self):
         return '<%s %r>' % (self.__class__.__name__, self.path)
 
     def __str__(self):
         return self.__repr__()
 
     def __unicode__(self):
         return self.name
 
     def get_parent_path(self):
         """
         Returns node's parent path or empty string if node is root.
         """
         if self.is_root():
             return ''
         return vcspath.dirname(self.path.rstrip('/')) + '/'
 
     def is_file(self):
         """
         Returns ``True`` if node's kind is ``NodeKind.FILE``, ``False``
         otherwise.
         """
         return self.kind == NodeKind.FILE
 
     def is_dir(self):
         """
         Returns ``True`` if node's kind is ``NodeKind.DIR``, ``False``
         otherwise.
         """
         return self.kind == NodeKind.DIR
 
     def is_root(self):
         """
         Returns ``True`` if node is a root node and ``False`` otherwise.
         """
         return self.kind == NodeKind.DIR and self.path == ''
 
     def is_submodule(self):
         """
         Returns ``True`` if node's kind is ``NodeKind.SUBMODULE``, ``False``
         otherwise.
         """
         return self.kind == NodeKind.SUBMODULE
 
     def is_largefile(self):
         """
         Returns ``True`` if node's kind is ``NodeKind.LARGEFILE``, ``False``
         otherwise
         """
         return self.kind == NodeKind.LARGEFILE
 
     def is_link(self):
         if self.commit:
             return self.commit.is_link(self.path)
         return False
 
     @LazyProperty
     def added(self):
         return self.state is NodeState.ADDED
 
     @LazyProperty
     def changed(self):
         return self.state is NodeState.CHANGED
 
     @LazyProperty
     def not_changed(self):
         return self.state is NodeState.NOT_CHANGED
 
     @LazyProperty
     def removed(self):
         return self.state is NodeState.REMOVED
 
 
 class FileNode(Node):
     """
     Class representing file nodes.
 
     :attribute: path: path to the node, relative to repository's root
     :attribute: content: if given arbitrary sets content of the file
     :attribute: commit: if given, first time content is accessed, callback
     :attribute: mode: stat mode for a node. Default is `FILEMODE_DEFAULT`.
     """
     _filter_pre_load = []
 
     def __init__(self, path, content=None, commit=None, mode=None, pre_load=None):
         """
         Only one of ``content`` and ``commit`` may be given. Passing both
         would raise ``NodeError`` exception.
 
         :param path: relative path to the node
         :param content: content may be passed to constructor
         :param commit: if given, will use it to lazily fetch content
         :param mode: ST_MODE (i.e. 0100644)
         """
         if content and commit:
             raise NodeError("Cannot use both content and commit")
         super(FileNode, self).__init__(path, kind=NodeKind.FILE)
         self.commit = commit
         self._content = content
         self._mode = mode or FILEMODE_DEFAULT
 
         self._set_bulk_properties(pre_load)
 
     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
 
         for attr_name in pre_load:
             result = getattr(self, attr_name)
             if callable(result):
                 result = result()
             self.__dict__[attr_name] = result
 
     @LazyProperty
     def mode(self):
         """
         Returns lazily mode of the FileNode. If `commit` is not set, would
         use value given at initialization or `FILEMODE_DEFAULT` (default).
         """
         if self.commit:
             mode = self.commit.get_file_mode(self.path)
         else:
             mode = self._mode
         return mode
 
     @LazyProperty
     def raw_bytes(self):
         """
         Returns lazily the raw bytes of the FileNode.
         """
         if self.commit:
             if self._content is None:
                 self._content = self.commit.get_file_content(self.path)
             content = self._content
         else:
             content = self._content
         return content
 
     @LazyProperty
     def md5(self):
         """
         Returns md5 of the file node.
         """
         return md5(self.raw_bytes)
 
     @LazyProperty
     def content(self):
         """
         Returns lazily content of the FileNode. If possible, would try to
         decode content from UTF-8.
         """
         content = self.raw_bytes
 
         if self.is_binary:
             return content
         return safe_unicode(content)
 
     @LazyProperty
     def size(self):
         if self.commit:
             return self.commit.get_file_size(self.path)
         raise NodeError(
             "Cannot retrieve size of the file without related "
             "commit attribute")
 
     @LazyProperty
     def message(self):
         if self.commit:
             return self.last_commit.message
         raise NodeError(
             "Cannot retrieve message of the file without related "
             "commit attribute")
 
     @LazyProperty
     def last_commit(self):
         if self.commit:
             pre_load = ["author", "date", "message"]
             return self.commit.get_file_commit(self.path, pre_load=pre_load)
         raise NodeError(
             "Cannot retrieve last commit of the file without "
             "related commit attribute")
 
     def get_mimetype(self):
         """
         Mimetype is calculated based on the file's content. If ``_mimetype``
         attribute is available, it will be returned (backends which store
         mimetypes or can easily recognize them, should set this private
         attribute to indicate that type should *NOT* be calculated).
         """
 
         if hasattr(self, '_mimetype'):
             if (isinstance(self._mimetype, (tuple, list,)) and
                     len(self._mimetype) == 2):
                 return self._mimetype
             else:
                 raise NodeError('given _mimetype attribute must be an 2 '
                                 'element list or tuple')
 
         db = get_mimetypes_db()
         mtype, encoding = db.guess_type(self.name)
 
         if mtype is None:
             if self.is_binary:
                 mtype = 'application/octet-stream'
                 encoding = None
             else:
                 mtype = 'text/plain'
                 encoding = None
 
                 # try with pygments
                 try:
                     from pygments.lexers import get_lexer_for_filename
                     mt = get_lexer_for_filename(self.name).mimetypes
                 except Exception:
                     mt = None
 
                 if mt:
                     mtype = mt[0]
 
         return mtype, encoding
 
     @LazyProperty
     def mimetype(self):
         """
         Wrapper around full mimetype info. It returns only type of fetched
         mimetype without the encoding part. use get_mimetype function to fetch
         full set of (type,encoding)
         """
         return self.get_mimetype()[0]
 
     @LazyProperty
     def mimetype_main(self):
         return self.mimetype.split('/')[0]
 
     @classmethod
     def get_lexer(cls, filename, content=None):
         from pygments import lexers
 
         extension = filename.split('.')[-1]
         lexer = None
 
         try:
             lexer = lexers.guess_lexer_for_filename(
                 filename, content, stripnl=False)
         except lexers.ClassNotFound:
             lexer = None
 
         # try our EXTENSION_MAP
         if not lexer:
             try:
                 lexer_class = LANGUAGES_EXTENSIONS_MAP.get(extension)
                 if lexer_class:
                     lexer = lexers.get_lexer_by_name(lexer_class[0])
             except lexers.ClassNotFound:
                 lexer = None
 
         if not lexer:
             lexer = lexers.TextLexer(stripnl=False)
 
         return lexer
 
     @LazyProperty
     def lexer(self):
         """
         Returns pygment's lexer class. Would try to guess lexer taking file's
         content, name and mimetype.
         """
         return self.get_lexer(self.name, self.content)
 
     @LazyProperty
     def lexer_alias(self):
         """
         Returns first alias of the lexer guessed for this file.
         """
         return self.lexer.aliases[0]
 
     @LazyProperty
     def history(self):
         """
         Returns a list of commit for this file in which the file was changed
         """
         if self.commit is None:
             raise NodeError('Unable to get commit for this FileNode')
         return self.commit.get_file_history(self.path)
 
     @LazyProperty
     def annotate(self):
         """
         Returns a list of three element tuples with lineno, commit and line
         """
         if self.commit is None:
             raise NodeError('Unable to get commit for this FileNode')
         pre_load = ["author", "date", "message"]
         return self.commit.get_file_annotate(self.path, pre_load=pre_load)
 
     @LazyProperty
     def state(self):
         if not self.commit:
             raise NodeError(
                 "Cannot check state of the node if it's not "
                 "linked with commit")
         elif self.path in (node.path for node in self.commit.added):
             return NodeState.ADDED
         elif self.path in (node.path for node in self.commit.changed):
             return NodeState.CHANGED
         else:
             return NodeState.NOT_CHANGED
 
     @LazyProperty
     def is_binary(self):
         """
         Returns True if file has binary content.
         """
         _bin = self.raw_bytes and '\0' in self.raw_bytes
         return _bin
 
     @LazyProperty
     def extension(self):
         """Returns filenode extension"""
         return self.name.split('.')[-1]
 
     @property
     def is_executable(self):
         """
         Returns ``True`` if file has executable flag turned on.
         """
         return bool(self.mode & stat.S_IXUSR)
 
     def get_largefile_node(self):
         """
         Try to return a Mercurial FileNode from this node. It does internal
         checks inside largefile store, if that file exist there it will
         create special instance of LargeFileNode which can get content from
         LF store.
         """
-        if self.commit and self.path.startswith(LARGEFILE_PREFIX):
-            largefile_path = self.path.split(LARGEFILE_PREFIX)[-1].lstrip('/')
-            return self.commit.get_largefile_node(largefile_path)
+        if self.commit:
+            return self.commit.get_largefile_node(self.path)
 
     def lines(self, count_empty=False):
         all_lines, empty_lines = 0, 0
 
         if not self.is_binary:
             content = self.content
             if count_empty:
                 all_lines = 0
                 empty_lines = 0
                 for line in content.splitlines(True):
                     if line == '\n':
                         empty_lines += 1
                     all_lines += 1
 
                 return all_lines, all_lines - empty_lines
             else:
                 # fast method
                 empty_lines = all_lines = content.count('\n')
                 if all_lines == 0 and content:
                     # one-line without a newline
                     empty_lines = all_lines = 1
 
         return all_lines, empty_lines
 
     def __repr__(self):
         return '<%s %r @ %s>' % (self.__class__.__name__, self.path,
                                  getattr(self.commit, 'short_id', ''))
 
 
 class RemovedFileNode(FileNode):
     """
     Dummy FileNode class - trying to access any public attribute except path,
     name, kind or state (or methods/attributes checking those two) would raise
     RemovedFileNodeError.
     """
     ALLOWED_ATTRIBUTES = [
         'name', 'path', 'state', 'is_root', 'is_file', 'is_dir', 'kind',
         'added', 'changed', 'not_changed', 'removed'
     ]
 
     def __init__(self, path):
         """
         :param path: relative path to the node
         """
         super(RemovedFileNode, self).__init__(path=path)
 
     def __getattribute__(self, attr):
         if attr.startswith('_') or attr in RemovedFileNode.ALLOWED_ATTRIBUTES:
             return super(RemovedFileNode, self).__getattribute__(attr)
         raise RemovedFileNodeError(
             "Cannot access attribute %s on RemovedFileNode" % attr)
 
     @LazyProperty
     def state(self):
         return NodeState.REMOVED
 
 
 class DirNode(Node):
     """
     DirNode stores list of files and directories within this node.
     Nodes may be used standalone but within repository context they
     lazily fetch data within same repositorty's commit.
     """
 
     def __init__(self, path, nodes=(), commit=None):
         """
         Only one of ``nodes`` and ``commit`` may be given. Passing both
         would raise ``NodeError`` exception.
 
         :param path: relative path to the node
         :param nodes: content may be passed to constructor
         :param commit: if given, will use it to lazily fetch content
         """
         if nodes and commit:
             raise NodeError("Cannot use both nodes and commit")
         super(DirNode, self).__init__(path, NodeKind.DIR)
         self.commit = commit
         self._nodes = nodes
 
     @LazyProperty
     def content(self):
         raise NodeError(
             "%s represents a dir and has no `content` attribute" % self)
 
     @LazyProperty
     def nodes(self):
         if self.commit:
             nodes = self.commit.get_nodes(self.path)
         else:
             nodes = self._nodes
         self._nodes_dict = dict((node.path, node) for node in nodes)
         return sorted(nodes)
 
     @LazyProperty
     def files(self):
         return sorted((node for node in self.nodes if node.is_file()))
 
     @LazyProperty
     def dirs(self):
         return sorted((node for node in self.nodes if node.is_dir()))
 
     def __iter__(self):
         for node in self.nodes:
             yield node
 
     def get_node(self, path):
         """
         Returns node from within this particular ``DirNode``, so it is now
         allowed to fetch, i.e. node located at 'docs/api/index.rst' from node
         'docs'. In order to access deeper nodes one must fetch nodes between
         them first - this would work::
 
            docs = root.get_node('docs')
            docs.get_node('api').get_node('index.rst')
 
         :param: path - relative to the current node
 
         .. note::
            To access lazily (as in example above) node have to be initialized
            with related commit object - without it node is out of
            context and may know nothing about anything else than nearest
            (located at same level) nodes.
         """
         try:
             path = path.rstrip('/')
             if path == '':
                 raise NodeError("Cannot retrieve node without path")
             self.nodes  # access nodes first in order to set _nodes_dict
             paths = path.split('/')
             if len(paths) == 1:
                 if not self.is_root():
                     path = '/'.join((self.path, paths[0]))
                 else:
                     path = paths[0]
                 return self._nodes_dict[path]
             elif len(paths) > 1:
                 if self.commit is None:
                     raise NodeError(
                         "Cannot access deeper nodes without commit")
                 else:
                     path1, path2 = paths[0], '/'.join(paths[1:])
                     return self.get_node(path1).get_node(path2)
             else:
                 raise KeyError
         except KeyError:
             raise NodeError("Node does not exist at %s" % path)
 
     @LazyProperty
     def state(self):
         raise NodeError("Cannot access state of DirNode")
 
     @LazyProperty
     def size(self):
         size = 0
         for root, dirs, files in self.commit.walk(self.path):
             for f in files:
                 size += f.size
 
         return size
 
     def __repr__(self):
         return '<%s %r @ %s>' % (self.__class__.__name__, self.path,
                                  getattr(self.commit, 'short_id', ''))
 
 
 class RootNode(DirNode):
     """
     DirNode being the root node of the repository.
     """
 
     def __init__(self, nodes=(), commit=None):
         super(RootNode, self).__init__(path='', nodes=nodes, commit=commit)
 
     def __repr__(self):
         return '<%s>' % self.__class__.__name__
 
 
 class SubModuleNode(Node):
     """
     represents a SubModule of Git or SubRepo of Mercurial
     """
     is_binary = False
     size = 0
 
     def __init__(self, name, url=None, commit=None, alias=None):
         self.path = name
         self.kind = NodeKind.SUBMODULE
         self.alias = alias
 
         # we have to use EmptyCommit here since this can point to svn/git/hg
         # submodules we cannot get from repository
         self.commit = EmptyCommit(str(commit), alias=alias)
         self.url = url or self._extract_submodule_url()
 
     def __repr__(self):
         return '<%s %r @ %s>' % (self.__class__.__name__, self.path,
                                  getattr(self.commit, 'short_id', ''))
 
     def _extract_submodule_url(self):
         # TODO: find a way to parse gits submodule file and extract the
         # linking URL
         return self.path
 
     @LazyProperty
     def name(self):
         """
         Returns name of the node so if its path
         then only last part is returned.
         """
         org = safe_unicode(self.path.rstrip('/').split('/')[-1])
         return u'%s @ %s' % (org, self.commit.short_id)
 
 
 class LargeFileNode(FileNode):
 
+    def __init__(self, path, url=None, commit=None, alias=None, org_path=None):
+        self.path = path
+        self.org_path = org_path
+        self.kind = NodeKind.LARGEFILE
+        self.alias = alias
+
     def _validate_path(self, path):
         """
         we override check since the LargeFileNode path is system absolute
         """
+        pass
 
+    def __repr__(self):
+        return '<%s %r>' % (self.__class__.__name__, self.path)
+
+    @LazyProperty
+    def size(self):
+        return os.stat(self.path).st_size
+
+    @LazyProperty
     def raw_bytes(self):
         if self.commit:
             with open(self.path, 'rb') as f:
                 content = f.read()
         else:
             content = self._content
-        return content
  No newline at end of file
+        return content
+
+    @LazyProperty
+    def name(self):
+        """
+        Overwrites name to be the org lf path
+        """
+        return self.org_path

rhodecode/templates/files/files_source.mako

@@ -1,78 +1,87 b''
 <%namespace name="sourceblock" file="/codeblocks/source.mako"/>
 
 <div id="codeblock" class="codeblock">
     <div class="codeblock-header">
       <div class="stats">
             <span> <strong>${c.file}</strong></span>
+            % if c.lf_node:
+            <span title="${_('This file is a pointer to large binary file')}"> | ${_('LargeFile')} ${h.format_byte_size_binary(c.lf_node.size)} </span>
+            % endif
             <span> | ${c.file.lines()[0]} ${ungettext('line', 'lines', c.file.lines()[0])}</span>
             <span> | ${h.format_byte_size_binary(c.file.size)}</span>
             <span> | ${c.file.mimetype} </span>
             <span class="item last"> | ${h.get_lexer_for_filenode(c.file).__class__.__name__}</span>
       </div>
       <div class="buttons">
         <a id="file_history_overview" href="#">
             ${_('History')}
         </a>
         <a id="file_history_overview_full" style="display: none" href="${h.url('changelog_file_home',repo_name=c.repo_name, revision=c.commit.raw_id, f_path=c.f_path)}">
            ${_('Show Full History')}
         </a> |
         %if c.annotate:
           ${h.link_to(_('Source'), h.url('files_home', repo_name=c.repo_name,revision=c.commit.raw_id,f_path=c.f_path))}
         %else:
           ${h.link_to(_('Annotation'), h.url('files_annotate_home',repo_name=c.repo_name,revision=c.commit.raw_id,f_path=c.f_path))}
         %endif
          | ${h.link_to(_('Raw'), h.url('files_raw_home',repo_name=c.repo_name,revision=c.commit.raw_id,f_path=c.f_path))}
-         | <a href="${h.url('files_rawfile_home',repo_name=c.repo_name,revision=c.commit.raw_id,f_path=c.f_path)}">
-          ${_('Download')}
-        </a>
+         |
+          % if c.lf_node:
+              <a href="${h.url('files_rawfile_home',repo_name=c.repo_name,revision=c.commit.raw_id,f_path=c.f_path, lf=1)}">
+              ${_('Download largefile')}
+              </a>
+          % else:
+              <a href="${h.url('files_rawfile_home',repo_name=c.repo_name,revision=c.commit.raw_id,f_path=c.f_path)}">
+              ${_('Download')}
+              </a>
+          % endif
 
         %if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name):
            |
          %if c.on_branch_head and c.branch_or_raw_id and not c.file.is_binary:
             <a href="${h.url('files_edit_home',repo_name=c.repo_name,revision=c.branch_or_raw_id,f_path=c.f_path, anchor='edit')}">
               ${_('Edit on Branch:%s') % c.branch_or_raw_id}
             </a>
             | <a class="btn-danger btn-link" href="${h.url('files_delete_home',repo_name=c.repo_name,revision=c.branch_or_raw_id,f_path=c.f_path, anchor='edit')}">${_('Delete')}
             </a>
          %elif c.on_branch_head and c.branch_or_raw_id and c.file.is_binary:
           ${h.link_to(_('Edit'), '#', class_="btn btn-link disabled tooltip", title=_('Editing binary files not allowed'))}
            | ${h.link_to(_('Delete'), h.url('files_delete_home',repo_name=c.repo_name,revision=c.branch_or_raw_id,f_path=c.f_path, anchor='edit'),class_="btn-danger btn-link")}
          %else:
           ${h.link_to(_('Edit'), '#', class_="btn btn-link disabled tooltip", title=_('Editing files allowed only when on branch head commit'))}
            | ${h.link_to(_('Delete'), '#', class_="btn btn-danger btn-link disabled tooltip", title=_('Deleting files allowed only when on branch head commit'))}
          %endif
         %endif
       </div>
     </div>
     <div id="file_history_container"></div>
     <div class="code-body">
-       %if c.file.is_binary:
+     %if c.file.is_binary:
            <div>
            ${_('Binary file (%s)') % c.file.mimetype}
            </div>
-       %else:
+     %else:
         % if c.file.size < c.cut_off_limit:
             %if c.renderer and not c.annotate:
                 ${h.render(c.file.content, renderer=c.renderer, relative_url=h.url('files_raw_home',repo_name=c.repo_name,revision=c.commit.raw_id,f_path=c.f_path))}
             %else:
                 <table class="cb codehilite">
                 %if c.annotate:
                   <% color_hasher = h.color_hasher() %>
                   %for annotation, lines in c.annotated_lines:
                     ${sourceblock.render_annotation_lines(annotation, lines, color_hasher)}
                   %endfor
                 %else:
                   %for line_num, tokens in enumerate(c.lines, 1):
                     ${sourceblock.render_line(line_num, tokens)}
                   %endfor
                 %endif
                 </table>
-              </div>
             %endif
         %else:
             ${_('File is too big to display')} ${h.link_to(_('Show as raw'),
             h.url('files_raw_home',repo_name=c.repo_name,revision=c.commit.raw_id,f_path=c.f_path))}
         %endif
      %endif
     </div>
 </div>
  No newline at end of file

rhodecode/tests/plugin.py

@@ -1,1809 +1,1814 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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 collections
 import datetime
 import hashlib
 import os
 import re
 import pprint
 import shutil
 import socket
 import subprocess32
 import time
 import uuid
 import dateutil.tz
 
 import mock
 import pyramid.testing
 import pytest
 import colander
 import requests
 
 import rhodecode
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
     PullRequest, Repository, RhodeCodeSetting, ChangesetStatus, RepoGroup,
     UserGroup, RepoRhodeCodeUi, RepoRhodeCodeSetting, RhodeCodeUi)
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.settings import VcsSettingsModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
 from rhodecode.lib.utils import repo2db_mapper
 from rhodecode.lib.vcs import create_vcsserver_proxy
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.tests import (
     login_user_session, get_new_dir, utils, TESTS_TMP_PATH,
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR2_LOGIN,
     TEST_USER_REGULAR_PASS)
 from rhodecode.tests.utils import CustomTestApp
 from rhodecode.tests.fixture import Fixture
 
 
 def _split_comma(value):
     return value.split(',')
 
 
 def pytest_addoption(parser):
     parser.addoption(
         '--keep-tmp-path', action='store_true',
         help="Keep the test temporary directories")
     parser.addoption(
         '--backends', action='store', type=_split_comma,
         default=['git', 'hg', 'svn'],
         help="Select which backends to test for backend specific tests.")
     parser.addoption(
         '--dbs', action='store', type=_split_comma,
         default=['sqlite'],
         help="Select which database to test for database specific tests. "
              "Possible options are sqlite,postgres,mysql")
     parser.addoption(
         '--appenlight', '--ae', action='store_true',
         help="Track statistics in appenlight.")
     parser.addoption(
         '--appenlight-api-key', '--ae-key',
         help="API key for Appenlight.")
     parser.addoption(
         '--appenlight-url', '--ae-url',
         default="https://ae.rhodecode.com",
         help="Appenlight service URL, defaults to https://ae.rhodecode.com")
     parser.addoption(
         '--sqlite-connection-string', action='store',
         default='', help="Connection string for the dbs tests with SQLite")
     parser.addoption(
         '--postgres-connection-string', action='store',
         default='', help="Connection string for the dbs tests with Postgres")
     parser.addoption(
         '--mysql-connection-string', action='store',
         default='', help="Connection string for the dbs tests with MySQL")
     parser.addoption(
         '--repeat', type=int, default=100,
         help="Number of repetitions in performance tests.")
 
 
 def pytest_configure(config):
     # Appy the kombu patch early on, needed for test discovery on Python 2.7.11
     from rhodecode.config import patches
     patches.kombu_1_5_1_python_2_7_11()
 
 
 def pytest_collection_modifyitems(session, config, items):
     # nottest marked, compare nose, used for transition from nose to pytest
     remaining = [
         i for i in items if getattr(i.obj, '__test__', True)]
     items[:] = remaining
 
 
 def pytest_generate_tests(metafunc):
     # Support test generation based on --backend parameter
     if 'backend_alias' in metafunc.fixturenames:
         backends = get_backends_from_metafunc(metafunc)
         scope = None
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
         metafunc.parametrize('backend_alias', backends, scope=scope)
     elif hasattr(metafunc.function, 'backends'):
         backends = get_backends_from_metafunc(metafunc)
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
 
 
 def get_backends_from_metafunc(metafunc):
     requested_backends = set(metafunc.config.getoption('--backends'))
     if hasattr(metafunc.function, 'backends'):
         # Supported backends by this test function, created from
         # pytest.mark.backends
         backends = metafunc.function.backends.args
     elif hasattr(metafunc.cls, 'backend_alias'):
         # Support class attribute "backend_alias", this is mainly
         # for legacy reasons for tests not yet using pytest.mark.backends
         backends = [metafunc.cls.backend_alias]
     else:
         backends = metafunc.config.getoption('--backends')
     return requested_backends.intersection(backends)
 
 
 @pytest.fixture(scope='session', autouse=True)
 def activate_example_rcextensions(request):
     """
     Patch in an example rcextensions module which verifies passed in kwargs.
     """
     from rhodecode.tests.other import example_rcextensions
 
     old_extensions = rhodecode.EXTENSIONS
     rhodecode.EXTENSIONS = example_rcextensions
 
     @request.addfinalizer
     def cleanup():
         rhodecode.EXTENSIONS = old_extensions
 
 
 @pytest.fixture
 def capture_rcextensions():
     """
     Returns the recorded calls to entry points in rcextensions.
     """
     calls = rhodecode.EXTENSIONS.calls
     calls.clear()
     # Note: At this moment, it is still the empty dict, but that will
     # be filled during the test run and since it is a reference this
     # is enough to make it work.
     return calls
 
 
 @pytest.fixture(scope='session')
 def http_environ_session():
     """
     Allow to use "http_environ" in session scope.
     """
     return http_environ(
         http_host_stub=http_host_stub())
 
 
 @pytest.fixture
 def http_host_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return 'test.example.com:80'
 
 
 @pytest.fixture
 def http_environ(http_host_stub):
     """
     HTTP extra environ keys.
 
     User by the test application and as well for setting up the pylons
     environment. In the case of the fixture "app" it should be possible
     to override this for a specific test case.
     """
     return {
         'SERVER_NAME': http_host_stub.split(':')[0],
         'SERVER_PORT': http_host_stub.split(':')[1],
         'HTTP_HOST': http_host_stub,
         'HTTP_USER_AGENT': 'rc-test-agent',
         'REQUEST_METHOD': 'GET'
     }
 
 
 @pytest.fixture(scope='function')
 def app(request, pylonsapp, http_environ):
     app = CustomTestApp(
         pylonsapp,
         extra_environ=http_environ)
     if request.cls:
         request.cls.app = app
     return app
 
 
 @pytest.fixture(scope='session')
 def app_settings(pylonsapp, pylons_config):
     """
     Settings dictionary used to create the app.
 
     Parses the ini file and passes the result through the sanitize and apply
     defaults mechanism in `rhodecode.config.middleware`.
     """
     from paste.deploy.loadwsgi import loadcontext, APP
     from rhodecode.config.middleware import (
         sanitize_settings_and_apply_defaults)
     context = loadcontext(APP, 'config:' + pylons_config)
     settings = sanitize_settings_and_apply_defaults(context.config())
     return settings
 
 
 @pytest.fixture(scope='session')
 def db(app_settings):
     """
     Initializes the database connection.
 
     It uses the same settings which are used to create the ``pylonsapp`` or
     ``app`` fixtures.
     """
     from rhodecode.config.utils import initialize_database
     initialize_database(app_settings)
 
 
 LoginData = collections.namedtuple('LoginData', ('csrf_token', 'user'))
 
 
 def _autologin_user(app, *args):
     session = login_user_session(app, *args)
     csrf_token = rhodecode.lib.auth.get_csrf_token(session)
     return LoginData(csrf_token, session['rhodecode_user'])
 
 
 @pytest.fixture
 def autologin_user(app):
     """
     Utility fixture which makes sure that the admin user is logged in
     """
     return _autologin_user(app)
 
 
 @pytest.fixture
 def autologin_regular_user(app):
     """
     Utility fixture which makes sure that the regular user is logged in
     """
     return _autologin_user(
         app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
 
 
 @pytest.fixture(scope='function')
 def csrf_token(request, autologin_user):
     return autologin_user.csrf_token
 
 
 @pytest.fixture(scope='function')
 def xhr_header(request):
     return {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
 
 
 @pytest.fixture
 def real_crypto_backend(monkeypatch):
     """
     Switch the production crypto backend on for this test.
 
     During the test run the crypto backend is replaced with a faster
     implementation based on the MD5 algorithm.
     """
     monkeypatch.setattr(rhodecode, 'is_test', False)
 
 
 @pytest.fixture(scope='class')
 def index_location(request, pylonsapp):
     index_location = pylonsapp.config['app_conf']['search.location']
     if request.cls:
         request.cls.index_location = index_location
     return index_location
 
 
 @pytest.fixture(scope='session', autouse=True)
 def tests_tmp_path(request):
     """
     Create temporary directory to be used during the test session.
     """
     if not os.path.exists(TESTS_TMP_PATH):
         os.makedirs(TESTS_TMP_PATH)
 
     if not request.config.getoption('--keep-tmp-path'):
         @request.addfinalizer
         def remove_tmp_path():
             shutil.rmtree(TESTS_TMP_PATH)
 
     return TESTS_TMP_PATH
 
 
 @pytest.fixture
 def test_repo_group(request):
     """
     Create a temporary repository group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     repogroupid = 'test_repo_group_%s' % int(time.time())
     repo_group = fixture.create_repo_group(repogroupid)
 
     def _cleanup():
         fixture.destroy_repo_group(repogroupid)
 
     request.addfinalizer(_cleanup)
     return repo_group
 
 
 @pytest.fixture
 def test_user_group(request):
     """
     Create a temporary user group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     usergroupid = 'test_user_group_%s' % int(time.time())
     user_group = fixture.create_user_group(usergroupid)
 
     def _cleanup():
         fixture.destroy_user_group(user_group)
 
     request.addfinalizer(_cleanup)
     return user_group
 
 
 @pytest.fixture(scope='session')
 def test_repo(request):
     container = TestRepoContainer()
     request.addfinalizer(container._cleanup)
     return container
 
 
 class TestRepoContainer(object):
     """
     Container for test repositories which are used read only.
 
     Repositories will be created on demand and re-used during the lifetime
     of this object.
 
     Usage to get the svn test repository "minimal"::
 
        test_repo = TestContainer()
        repo = test_repo('minimal', 'svn')
 
     """
 
     dump_extractors = {
         'git': utils.extract_git_repo_from_dump,
         'hg': utils.extract_hg_repo_from_dump,
         'svn': utils.extract_svn_repo_from_dump,
     }
 
     def __init__(self):
         self._cleanup_repos = []
         self._fixture = Fixture()
         self._repos = {}
 
-    def __call__(self, dump_name, backend_alias):
+    def __call__(self, dump_name, backend_alias, config=None):
         key = (dump_name, backend_alias)
         if key not in self._repos:
-            repo = self._create_repo(dump_name, backend_alias)
+            repo = self._create_repo(dump_name, backend_alias, config)
             self._repos[key] = repo.repo_id
         return Repository.get(self._repos[key])
 
-    def _create_repo(self, dump_name, backend_alias):
+    def _create_repo(self, dump_name, backend_alias, config):
         repo_name = '%s-%s' % (backend_alias, dump_name)
         backend_class = get_backend(backend_alias)
         dump_extractor = self.dump_extractors[backend_alias]
         repo_path = dump_extractor(dump_name, repo_name)
-        vcs_repo = backend_class(repo_path)
+
+        vcs_repo = backend_class(repo_path, config=config)
         repo2db_mapper({repo_name: vcs_repo})
+
         repo = RepoModel().get_by_repo_name(repo_name)
         self._cleanup_repos.append(repo_name)
         return repo
 
     def _cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
 
 @pytest.fixture
 def backend(request, backend_alias, pylonsapp, test_repo):
     """
     Parametrized fixture which represents a single backend implementation.
 
     It respects the option `--backends` to focus the test run on specific
     backend implementations.
 
     It also supports `pytest.mark.xfail_backends` to mark tests as failing
     for specific backends. This is intended as a utility for incremental
     development of a new backend implementation.
     """
     if backend_alias not in request.config.getoption('--backends'):
         pytest.skip("Backend %s not selected." % (backend_alias, ))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = 'vcs_test_%s' % (backend_alias, )
     backend = Backend(
         alias=backend_alias,
         repo_name=repo_name,
         test_name=request.node.name,
         test_repo_container=test_repo)
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture
 def backend_git(request, pylonsapp, test_repo):
     return backend(request, 'git', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_hg(request, pylonsapp, test_repo):
     return backend(request, 'hg', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_svn(request, pylonsapp, test_repo):
     return backend(request, 'svn', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_random(backend_git):
     """
     Use this to express that your tests need "a backend.
 
     A few of our tests need a backend, so that we can run the code. This
     fixture is intended to be used for such cases. It will pick one of the
     backends and run the tests.
 
     The fixture `backend` would run the test multiple times for each
     available backend which is a pure waste of time if the test is
     independent of the backend type.
     """
     # TODO: johbo: Change this to pick a random backend
     return backend_git
 
 
 @pytest.fixture
 def backend_stub(backend_git):
     """
     Use this to express that your tests need a backend stub
 
     TODO: mikhail: Implement a real stub logic instead of returning
     a git backend
     """
     return backend_git
 
 
 @pytest.fixture
 def repo_stub(backend_stub):
     """
     Use this to express that your tests need a repository stub
     """
     return backend_stub.create_repo()
 
 
 class Backend(object):
     """
     Represents the test configuration for one supported backend
 
     Provides easy access to different test repositories based on
     `__getitem__`. Such repositories will only be created once per test
     session.
     """
 
     invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
     _master_repo = None
     _commit_ids = {}
 
     def __init__(self, alias, repo_name, test_name, test_repo_container):
         self.alias = alias
         self.repo_name = repo_name
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
         # TODO: johbo: Used as a delegate interim. Not yet sure if Backend or
         # Fixture will survive in the end.
         self._fixture = Fixture()
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias)
 
+    def create_test_repo(self, key, config=None):
+        return self._test_repo_container(key, self.alias, config)
+
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo or the
         last repo which has been created with `create_repo`.
         """
         from rhodecode.model.db import Repository
         return Repository.get_by_repo_name(self.repo_name)
 
     @property
     def default_branch_name(self):
         VcsRepository = get_backend(self.alias)
         return VcsRepository.DEFAULT_BRANCH_NAME
 
     @property
     def default_head_id(self):
         """
         Returns the default head id of the underlying backend.
 
         This will be the default branch name in case the backend does have a
         default branch. In the other cases it will point to a valid head
         which can serve as the base to create a new commit on top of it.
         """
         vcsrepo = self.repo.scm_instance()
         head_id = (
             vcsrepo.DEFAULT_BRANCH_NAME or
             vcsrepo.commit_ids[-1])
         return head_id
 
     @property
     def commit_ids(self):
         """
         Returns the list of commits for the last created repository
         """
         return self._commit_ids
 
     def create_master_repo(self, commits):
         """
         Create a repository and remember it as a template.
 
         This allows to easily create derived repositories to construct
         more complex scenarios for diff, compare and pull requests.
 
         Returns a commit map which maps from commit message to raw_id.
         """
         self._master_repo = self.create_repo(commits=commits)
         return self._commit_ids
 
     def create_repo(
             self, commits=None, number_of_commits=0, heads=None,
             name_suffix=u'', **kwargs):
         """
         Create a repository and record it for later cleanup.
 
         :param commits: Optional. A sequence of dict instances.
            Will add a commit per entry to the new repository.
         :param number_of_commits: Optional. If set to a number, this number of
            commits will be added to the new repository.
         :param heads: Optional. Can be set to a sequence of of commit
            names which shall be pulled in from the master repository.
 
         """
         self.repo_name = self._next_repo_name() + name_suffix
         repo = self._fixture.create_repo(
             self.repo_name, repo_type=self.alias, **kwargs)
         self._cleanup_repos.append(repo.repo_name)
 
         commits = commits or [
             {'message': 'Commit %s of %s' % (x, self.repo_name)}
             for x in xrange(number_of_commits)]
         self._add_commits_to_repo(repo.scm_instance(), commits)
         if heads:
             self.pull_heads(repo, heads)
 
         return repo
 
     def pull_heads(self, repo, heads):
         """
         Make sure that repo contains all commits mentioned in `heads`
         """
         vcsmaster = self._master_repo.scm_instance()
         vcsrepo = repo.scm_instance()
         vcsrepo.config.clear_section('hooks')
         commit_ids = [self._commit_ids[h] for h in heads]
         vcsrepo.pull(vcsmaster.path, commit_ids=commit_ids)
 
     def create_fork(self):
         repo_to_fork = self.repo_name
         self.repo_name = self._next_repo_name()
         repo = self._fixture.create_fork(repo_to_fork, self.repo_name)
         self._cleanup_repos.append(self.repo_name)
         return repo
 
     def new_repo_name(self, suffix=u''):
         self.repo_name = self._next_repo_name() + suffix
         self._cleanup_repos.append(self.repo_name)
         return self.repo_name
 
     def _next_repo_name(self):
         return u"%s_%s" % (
             self.invalid_repo_name.sub(u'_', self._test_name),
             len(self._cleanup_repos))
 
     def ensure_file(self, filename, content='Test content\n'):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         commits = [
             {'added': [
                 FileNode(filename, content=content),
             ]},
         ]
         self._add_commits_to_repo(self.repo.scm_instance(), commits)
 
     def enable_downloads(self):
         repo = self.repo
         repo.enable_downloads = True
         Session().add(repo)
         Session().commit()
 
     def cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
     def _add_commits_to_repo(self, repo, commits):
         commit_ids = _add_commits_to_repo(repo, commits)
         if not commit_ids:
             return
         self._commit_ids = commit_ids
 
         # Creating refs for Git to allow fetching them from remote repository
         if self.alias == 'git':
             refs = {}
             for message in self._commit_ids:
                 # TODO: mikhail: do more special chars replacements
                 ref_name = 'refs/test-refs/{}'.format(
                     message.replace(' ', ''))
                 refs[ref_name] = self._commit_ids[message]
             self._create_refs(repo, refs)
 
     def _create_refs(self, repo, refs):
         for ref_name in refs:
             repo.set_refs(ref_name, refs[ref_name])
 
 
 @pytest.fixture
 def vcsbackend(request, backend_alias, tests_tmp_path, pylonsapp, test_repo):
     """
     Parametrized fixture which represents a single vcs backend implementation.
 
     See the fixture `backend` for more details. This one implements the same
     concept, but on vcs level. So it does not provide model instances etc.
 
     Parameters are generated dynamically, see :func:`pytest_generate_tests`
     for how this works.
     """
     if backend_alias not in request.config.getoption('--backends'):
         pytest.skip("Backend %s not selected." % (backend_alias, ))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = 'vcs_test_%s' % (backend_alias, )
     repo_path = os.path.join(tests_tmp_path, repo_name)
     backend = VcsBackend(
         alias=backend_alias,
         repo_path=repo_path,
         test_name=request.node.name,
         test_repo_container=test_repo)
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture
 def vcsbackend_git(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'git', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_hg(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'hg', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_svn(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'svn', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_random(vcsbackend_git):
     """
     Use this to express that your tests need "a vcsbackend".
 
     The fixture `vcsbackend` would run the test multiple times for each
     available vcs backend which is a pure waste of time if the test is
     independent of the vcs backend type.
     """
     # TODO: johbo: Change this to pick a random backend
     return vcsbackend_git
 
 
 @pytest.fixture
 def vcsbackend_stub(vcsbackend_git):
     """
     Use this to express that your test just needs a stub of a vcsbackend.
 
     Plan is to eventually implement an in-memory stub to speed tests up.
     """
     return vcsbackend_git
 
 
 class VcsBackend(object):
     """
     Represents the test configuration for one supported vcs backend.
     """
 
     invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
 
     def __init__(self, alias, repo_path, test_name, test_repo_container):
         self.alias = alias
         self._repo_path = repo_path
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias).scm_instance()
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo of the last
         repo which has been created.
         """
         Repository = get_backend(self.alias)
         return Repository(self._repo_path)
 
     @property
     def backend(self):
         """
         Returns the backend implementation class.
         """
         return get_backend(self.alias)
 
     def create_repo(self, commits=None, number_of_commits=0, _clone_repo=None):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         repo_class = get_backend(self.alias)
         src_url = None
         if _clone_repo:
             src_url = _clone_repo.path
         repo = repo_class(self._repo_path, create=True, src_url=src_url)
         self._cleanup_repos.append(repo)
 
         commits = commits or [
             {'message': 'Commit %s of %s' % (x, repo_name)}
             for x in xrange(number_of_commits)]
         _add_commits_to_repo(repo, commits)
         return repo
 
     def clone_repo(self, repo):
         return self.create_repo(_clone_repo=repo)
 
     def cleanup(self):
         for repo in self._cleanup_repos:
             shutil.rmtree(repo.path)
 
     def new_repo_path(self):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         return self._repo_path
 
     def _next_repo_name(self):
         return "%s_%s" % (
             self.invalid_repo_name.sub('_', self._test_name),
             len(self._cleanup_repos))
 
     def add_file(self, repo, filename, content='Test content\n'):
         imc = repo.in_memory_commit
         imc.add(FileNode(filename, content=content))
         imc.commit(
             message=u'Automatic commit from vcsbackend fixture',
             author=u'Automatic')
 
     def ensure_file(self, filename, content='Test content\n'):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         self.add_file(self.repo, filename, content)
 
 
 def _add_commits_to_repo(vcs_repo, commits):
     commit_ids = {}
     if not commits:
         return commit_ids
 
     imc = vcs_repo.in_memory_commit
     commit = None
 
     for idx, commit in enumerate(commits):
         message = unicode(commit.get('message', 'Commit %s' % idx))
 
         for node in commit.get('added', []):
             imc.add(FileNode(node.path, content=node.content))
         for node in commit.get('changed', []):
             imc.change(FileNode(node.path, content=node.content))
         for node in commit.get('removed', []):
             imc.remove(FileNode(node.path))
 
         parents = [
             vcs_repo.get_commit(commit_id=commit_ids[p])
             for p in commit.get('parents', [])]
 
         operations = ('added', 'changed', 'removed')
         if not any((commit.get(o) for o in operations)):
             imc.add(FileNode('file_%s' % idx, content=message))
 
         commit = imc.commit(
             message=message,
             author=unicode(commit.get('author', 'Automatic')),
             date=commit.get('date'),
             branch=commit.get('branch'),
             parents=parents)
 
         commit_ids[commit.message] = commit.raw_id
 
     return commit_ids
 
 
 @pytest.fixture
 def reposerver(request):
     """
     Allows to serve a backend repository
     """
 
     repo_server = RepoServer()
     request.addfinalizer(repo_server.cleanup)
     return repo_server
 
 
 class RepoServer(object):
     """
     Utility to serve a local repository for the duration of a test case.
 
     Supports only Subversion so far.
     """
 
     url = None
 
     def __init__(self):
         self._cleanup_servers = []
 
     def serve(self, vcsrepo):
         if vcsrepo.alias != 'svn':
             raise TypeError("Backend %s not supported" % vcsrepo.alias)
 
         proc = subprocess32.Popen(
             ['svnserve', '-d', '--foreground', '--listen-host', 'localhost',
              '--root', vcsrepo.path])
         self._cleanup_servers.append(proc)
         self.url = 'svn://localhost'
 
     def cleanup(self):
         for proc in self._cleanup_servers:
             proc.terminate()
 
 
 @pytest.fixture
 def pr_util(backend, request):
     """
     Utility for tests of models and for functional tests around pull requests.
 
     It gives an instance of :class:`PRTestUtility` which provides various
     utility methods around one pull request.
 
     This fixture uses `backend` and inherits its parameterization.
     """
 
     util = PRTestUtility(backend)
 
     @request.addfinalizer
     def cleanup():
         util.cleanup()
 
     return util
 
 
 class PRTestUtility(object):
 
     pull_request = None
     pull_request_id = None
     mergeable_patcher = None
     mergeable_mock = None
     notification_patcher = None
 
     def __init__(self, backend):
         self.backend = backend
 
     def create_pull_request(
             self, commits=None, target_head=None, source_head=None,
             revisions=None, approved=False, author=None, mergeable=False,
             enable_notifications=True, name_suffix=u'', reviewers=None,
             title=u"Test", description=u"Description"):
         self.set_mergeable(mergeable)
         if not enable_notifications:
             # mock notification side effect
             self.notification_patcher = mock.patch(
                 'rhodecode.model.notification.NotificationModel.create')
             self.notification_patcher.start()
 
         if not self.pull_request:
             if not commits:
                 commits = [
                     {'message': 'c1'},
                     {'message': 'c2'},
                     {'message': 'c3'},
                 ]
                 target_head = 'c1'
                 source_head = 'c2'
                 revisions = ['c2']
 
             self.commit_ids = self.backend.create_master_repo(commits)
             self.target_repository = self.backend.create_repo(
                 heads=[target_head], name_suffix=name_suffix)
             self.source_repository = self.backend.create_repo(
                 heads=[source_head], name_suffix=name_suffix)
             self.author = author or UserModel().get_by_username(
                 TEST_USER_ADMIN_LOGIN)
 
             model = PullRequestModel()
             self.create_parameters = {
                 'created_by': self.author,
                 'source_repo': self.source_repository.repo_name,
                 'source_ref': self._default_branch_reference(source_head),
                 'target_repo': self.target_repository.repo_name,
                 'target_ref': self._default_branch_reference(target_head),
                 'revisions': [self.commit_ids[r] for r in revisions],
                 'reviewers': reviewers or self._get_reviewers(),
                 'title': title,
                 'description': description,
             }
             self.pull_request = model.create(**self.create_parameters)
             assert model.get_versions(self.pull_request) == []
 
             self.pull_request_id = self.pull_request.pull_request_id
 
             if approved:
                 self.approve()
 
             Session().add(self.pull_request)
             Session().commit()
 
         return self.pull_request
 
     def approve(self):
         self.create_status_votes(
             ChangesetStatus.STATUS_APPROVED,
             *self.pull_request.reviewers)
 
     def close(self):
         PullRequestModel().close_pull_request(self.pull_request, self.author)
 
     def _default_branch_reference(self, commit_message):
         reference = '%s:%s:%s' % (
             'branch',
             self.backend.default_branch_name,
             self.commit_ids[commit_message])
         return reference
 
     def _get_reviewers(self):
         model = UserModel()
         return [
             model.get_by_username(TEST_USER_REGULAR_LOGIN),
             model.get_by_username(TEST_USER_REGULAR2_LOGIN),
         ]
 
     def update_source_repository(self, head=None):
         heads = [head or 'c3']
         self.backend.pull_heads(self.source_repository, heads=heads)
 
     def add_one_commit(self, head=None):
         self.update_source_repository(head=head)
         old_commit_ids = set(self.pull_request.revisions)
         PullRequestModel().update_commits(self.pull_request)
         commit_ids = set(self.pull_request.revisions)
         new_commit_ids = commit_ids - old_commit_ids
         assert len(new_commit_ids) == 1
         return new_commit_ids.pop()
 
     def remove_one_commit(self):
         assert len(self.pull_request.revisions) == 2
         source_vcs = self.source_repository.scm_instance()
         removed_commit_id = source_vcs.commit_ids[-1]
 
         # TODO: johbo: Git and Mercurial have an inconsistent vcs api here,
         # remove the if once that's sorted out.
         if self.backend.alias == "git":
             kwargs = {'branch_name': self.backend.default_branch_name}
         else:
             kwargs = {}
         source_vcs.strip(removed_commit_id, **kwargs)
 
         PullRequestModel().update_commits(self.pull_request)
         assert len(self.pull_request.revisions) == 1
         return removed_commit_id
 
     def create_comment(self, linked_to=None):
         comment = CommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_inline_comment(
             self, linked_to=None, line_no=u'n1', file_path='file_1'):
         comment = CommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             line_no=line_no,
             f_path=file_path,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_version_of_pull_request(self):
         pull_request = self.create_pull_request()
         version = PullRequestModel()._create_version_from_snapshot(
             pull_request)
         return version
 
     def create_status_votes(self, status, *reviewers):
         for reviewer in reviewers:
             ChangesetStatusModel().set_status(
                 repo=self.pull_request.target_repo,
                 status=status,
                 user=reviewer.user_id,
                 pull_request=self.pull_request)
 
     def set_mergeable(self, value):
         if not self.mergeable_patcher:
             self.mergeable_patcher = mock.patch.object(
                 VcsSettingsModel, 'get_general_settings')
             self.mergeable_mock = self.mergeable_patcher.start()
         self.mergeable_mock.return_value = {
             'rhodecode_pr_merge_enabled': value}
 
     def cleanup(self):
         # In case the source repository is already cleaned up, the pull
         # request will already be deleted.
         pull_request = PullRequest().get(self.pull_request_id)
         if pull_request:
             PullRequestModel().delete(pull_request)
             Session().commit()
 
         if self.notification_patcher:
             self.notification_patcher.stop()
 
         if self.mergeable_patcher:
             self.mergeable_patcher.stop()
 
 
 @pytest.fixture
 def user_admin(pylonsapp):
     """
     Provides the default admin test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
     return user
 
 
 @pytest.fixture
 def user_regular(pylonsapp):
     """
     Provides the default regular test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
     return user
 
 
 @pytest.fixture
 def user_util(request, pylonsapp):
     """
     Provides a wired instance of `UserUtility` with integrated cleanup.
     """
     utility = UserUtility(test_name=request.node.name)
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 # TODO: johbo: Split this up into utilities per domain or something similar
 class UserUtility(object):
 
     def __init__(self, test_name="test"):
         self._test_name = self._sanitize_name(test_name)
         self.fixture = Fixture()
         self.repo_group_ids = []
         self.repos_ids = []
         self.user_ids = []
         self.user_group_ids = []
         self.user_repo_permission_ids = []
         self.user_group_repo_permission_ids = []
         self.user_repo_group_permission_ids = []
         self.user_group_repo_group_permission_ids = []
         self.user_user_group_permission_ids = []
         self.user_group_user_group_permission_ids = []
         self.user_permissions = []
 
     def _sanitize_name(self, name):
         for char in ['[', ']']:
             name = name.replace(char, '_')
         return name
 
     def create_repo_group(
             self, owner=TEST_USER_ADMIN_LOGIN, auto_cleanup=True):
         group_name = "{prefix}_repogroup_{count}".format(
             prefix=self._test_name,
             count=len(self.repo_group_ids))
         repo_group = self.fixture.create_repo_group(
             group_name, cur_user=owner)
         if auto_cleanup:
             self.repo_group_ids.append(repo_group.group_id)
         return repo_group
 
     def create_repo(self, owner=TEST_USER_ADMIN_LOGIN, parent=None,
                     auto_cleanup=True, repo_type='hg'):
         repo_name = "{prefix}_repository_{count}".format(
             prefix=self._test_name,
             count=len(self.repos_ids))
 
         repository = self.fixture.create_repo(
             repo_name, cur_user=owner, repo_group=parent, repo_type=repo_type)
         if auto_cleanup:
             self.repos_ids.append(repository.repo_id)
         return repository
 
     def create_user(self, auto_cleanup=True, **kwargs):
         user_name = "{prefix}_user_{count}".format(
             prefix=self._test_name,
             count=len(self.user_ids))
         user = self.fixture.create_user(user_name, **kwargs)
         if auto_cleanup:
             self.user_ids.append(user.user_id)
         return user
 
     def create_user_with_group(self):
         user = self.create_user()
         user_group = self.create_user_group(members=[user])
         return user, user_group
 
     def create_user_group(self, owner=TEST_USER_ADMIN_LOGIN, members=None,
                           auto_cleanup=True, **kwargs):
         group_name = "{prefix}_usergroup_{count}".format(
             prefix=self._test_name,
             count=len(self.user_group_ids))
         user_group = self.fixture.create_user_group(
             group_name, cur_user=owner, **kwargs)
 
         if auto_cleanup:
             self.user_group_ids.append(user_group.users_group_id)
         if members:
             for user in members:
                 UserGroupModel().add_user_to_group(user_group, user)
         return user_group
 
     def grant_user_permission(self, user_name, permission_name):
         self._inherit_default_user_permissions(user_name, False)
         self.user_permissions.append((user_name, permission_name))
 
     def grant_user_permission_to_repo_group(
             self, repo_group, user, permission_name):
         permission = RepoGroupModel().grant_user_permission(
             repo_group, user, permission_name)
         self.user_repo_group_permission_ids.append(
             (repo_group.group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo_group(
             self, repo_group, user_group, permission_name):
         permission = RepoGroupModel().grant_user_group_permission(
             repo_group, user_group, permission_name)
         self.user_group_repo_group_permission_ids.append(
             (repo_group.group_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_repo(
             self, repo, user, permission_name):
         permission = RepoModel().grant_user_permission(
             repo, user, permission_name)
         self.user_repo_permission_ids.append(
             (repo.repo_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo(
             self, repo, user_group, permission_name):
         permission = RepoModel().grant_user_group_permission(
             repo, user_group, permission_name)
         self.user_group_repo_permission_ids.append(
             (repo.repo_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_user_group(
             self, target_user_group, user, permission_name):
         permission = UserGroupModel().grant_user_permission(
             target_user_group, user, permission_name)
         self.user_user_group_permission_ids.append(
             (target_user_group.users_group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_user_group(
             self, target_user_group, user_group, permission_name):
         permission = UserGroupModel().grant_user_group_permission(
             target_user_group, user_group, permission_name)
         self.user_group_user_group_permission_ids.append(
             (target_user_group.users_group_id, user_group.users_group_id))
         return permission
 
     def revoke_user_permission(self, user_name, permission_name):
         self._inherit_default_user_permissions(user_name, True)
         UserModel().revoke_perm(user_name, permission_name)
 
     def _inherit_default_user_permissions(self, user_name, value):
         user = UserModel().get_by_username(user_name)
         user.inherit_default_permissions = value
         Session().add(user)
         Session().commit()
 
     def cleanup(self):
         self._cleanup_permissions()
         self._cleanup_repos()
         self._cleanup_repo_groups()
         self._cleanup_user_groups()
         self._cleanup_users()
 
     def _cleanup_permissions(self):
         if self.user_permissions:
             for user_name, permission_name in self.user_permissions:
                 self.revoke_user_permission(user_name, permission_name)
 
         for permission in self.user_repo_permission_ids:
             RepoModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_permission_ids:
             RepoModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_repo_group_permission_ids:
             RepoGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_group_permission_ids:
             RepoGroupModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_user_group_permission_ids:
             UserGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_user_group_permission_ids:
             UserGroupModel().revoke_user_group_permission(*permission)
 
     def _cleanup_repo_groups(self):
         def _repo_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = RepoGroup.get(first_group_id)
             second_group = RepoGroup.get(second_group_id)
             first_group_parts = (
                 len(first_group.group_name.split('/')) if first_group else 0)
             second_group_parts = (
                 len(second_group.group_name.split('/')) if second_group else 0)
             return cmp(second_group_parts, first_group_parts)
 
         sorted_repo_group_ids = sorted(
             self.repo_group_ids, cmp=_repo_group_compare)
         for repo_group_id in sorted_repo_group_ids:
             self.fixture.destroy_repo_group(repo_group_id)
 
     def _cleanup_repos(self):
         sorted_repos_ids = sorted(self.repos_ids)
         for repo_id in sorted_repos_ids:
             self.fixture.destroy_repo(repo_id)
 
     def _cleanup_user_groups(self):
         def _user_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = UserGroup.get(first_group_id)
             second_group = UserGroup.get(second_group_id)
             first_group_parts = (
                 len(first_group.users_group_name.split('/'))
                 if first_group else 0)
             second_group_parts = (
                 len(second_group.users_group_name.split('/'))
                 if second_group else 0)
             return cmp(second_group_parts, first_group_parts)
 
         sorted_user_group_ids = sorted(
             self.user_group_ids, cmp=_user_group_compare)
         for user_group_id in sorted_user_group_ids:
             self.fixture.destroy_user_group(user_group_id)
 
     def _cleanup_users(self):
         for user_id in self.user_ids:
             self.fixture.destroy_user(user_id)
 
 
 # TODO: Think about moving this into a pytest-pyro package and make it a
 # pytest plugin
 @pytest.hookimpl(tryfirst=True, hookwrapper=True)
 def pytest_runtest_makereport(item, call):
     """
     Adding the remote traceback if the exception has this information.
 
     VCSServer attaches this information as the attribute `_vcs_server_traceback`
     to the exception instance.
     """
     outcome = yield
     report = outcome.get_result()
     if call.excinfo:
         _add_vcsserver_remote_traceback(report, call.excinfo.value)
 
 
 def _add_vcsserver_remote_traceback(report, exc):
     vcsserver_traceback = getattr(exc, '_vcs_server_traceback', None)
 
     if vcsserver_traceback:
         section = 'VCSServer remote traceback ' + report.when
         report.sections.append((section, vcsserver_traceback))
 
 
 @pytest.fixture(scope='session')
 def testrun():
     return {
         'uuid': uuid.uuid4(),
         'start': datetime.datetime.utcnow().isoformat(),
         'timestamp': int(time.time()),
     }
 
 
 @pytest.fixture(autouse=True)
 def collect_appenlight_stats(request, testrun):
     """
     This fixture reports memory consumtion of single tests.
 
     It gathers data based on `psutil` and sends them to Appenlight. The option
     ``--ae`` has te be used to enable this fixture and the API key for your
     application has to be provided in ``--ae-key``.
     """
     try:
         # cygwin cannot have yet psutil support.
         import psutil
     except ImportError:
         return
 
     if not request.config.getoption('--appenlight'):
         return
     else:
         # Only request the pylonsapp fixture if appenlight tracking is
         # enabled. This will speed up a test run of unit tests by 2 to 3
         # seconds if appenlight is not enabled.
         pylonsapp = request.getfuncargvalue("pylonsapp")
     url = '{}/api/logs'.format(request.config.getoption('--appenlight-url'))
     client = AppenlightClient(
         url=url,
         api_key=request.config.getoption('--appenlight-api-key'),
         namespace=request.node.nodeid,
         request=str(testrun['uuid']),
         testrun=testrun)
 
     client.collect({
         'message': "Starting",
     })
 
     server_and_port = pylonsapp.config['vcs.server']
     protocol = pylonsapp.config['vcs.server.protocol']
     server = create_vcsserver_proxy(server_and_port, protocol)
     with server:
         vcs_pid = server.get_pid()
         server.run_gc()
     vcs_process = psutil.Process(vcs_pid)
     mem = vcs_process.memory_info()
     client.tag_before('vcsserver.rss', mem.rss)
     client.tag_before('vcsserver.vms', mem.vms)
 
     test_process = psutil.Process()
     mem = test_process.memory_info()
     client.tag_before('test.rss', mem.rss)
     client.tag_before('test.vms', mem.vms)
 
     client.tag_before('time', time.time())
 
     @request.addfinalizer
     def send_stats():
         client.tag_after('time', time.time())
         with server:
             gc_stats = server.run_gc()
         for tag, value in gc_stats.items():
             client.tag_after(tag, value)
         mem = vcs_process.memory_info()
         client.tag_after('vcsserver.rss', mem.rss)
         client.tag_after('vcsserver.vms', mem.vms)
 
         mem = test_process.memory_info()
         client.tag_after('test.rss', mem.rss)
         client.tag_after('test.vms', mem.vms)
 
         client.collect({
             'message': "Finished",
         })
         client.send_stats()
 
     return client
 
 
 class AppenlightClient():
 
     url_template = '{url}?protocol_version=0.5'
 
     def __init__(
             self, url, api_key, add_server=True, add_timestamp=True,
             namespace=None, request=None, testrun=None):
         self.url = self.url_template.format(url=url)
         self.api_key = api_key
         self.add_server = add_server
         self.add_timestamp = add_timestamp
         self.namespace = namespace
         self.request = request
         self.server = socket.getfqdn(socket.gethostname())
         self.tags_before = {}
         self.tags_after = {}
         self.stats = []
         self.testrun = testrun or {}
 
     def tag_before(self, tag, value):
         self.tags_before[tag] = value
 
     def tag_after(self, tag, value):
         self.tags_after[tag] = value
 
     def collect(self, data):
         if self.add_server:
             data.setdefault('server', self.server)
         if self.add_timestamp:
             data.setdefault('date', datetime.datetime.utcnow().isoformat())
         if self.namespace:
             data.setdefault('namespace', self.namespace)
         if self.request:
             data.setdefault('request', self.request)
         self.stats.append(data)
 
     def send_stats(self):
         tags = [
             ('testrun', self.request),
             ('testrun.start', self.testrun['start']),
             ('testrun.timestamp', self.testrun['timestamp']),
             ('test', self.namespace),
         ]
         for key, value in self.tags_before.items():
             tags.append((key + '.before', value))
             try:
                 delta = self.tags_after[key] - value
                 tags.append((key + '.delta', delta))
             except Exception:
                 pass
         for key, value in self.tags_after.items():
             tags.append((key + '.after', value))
         self.collect({
             'message': "Collected tags",
             'tags': tags,
         })
 
         response = requests.post(
             self.url,
             headers={
                 'X-appenlight-api-key': self.api_key},
             json=self.stats,
         )
 
         if not response.status_code == 200:
             pprint.pprint(self.stats)
             print response.headers
             print response.text
             raise Exception('Sending to appenlight failed')
 
 
 @pytest.fixture
 def gist_util(request, pylonsapp):
     """
     Provides a wired instance of `GistUtility` with integrated cleanup.
     """
     utility = GistUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class GistUtility(object):
     def __init__(self):
         self.fixture = Fixture()
         self.gist_ids = []
 
     def create_gist(self, **kwargs):
         gist = self.fixture.create_gist(**kwargs)
         self.gist_ids.append(gist.gist_id)
         return gist
 
     def cleanup(self):
         for id_ in self.gist_ids:
             self.fixture.destroy_gists(str(id_))
 
 
 @pytest.fixture
 def enabled_backends(request):
     backends = request.config.option.backends
     return backends[:]
 
 
 @pytest.fixture
 def settings_util(request):
     """
     Provides a wired instance of `SettingsUtility` with integrated cleanup.
     """
     utility = SettingsUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class SettingsUtility(object):
     def __init__(self):
         self.rhodecode_ui_ids = []
         self.rhodecode_setting_ids = []
         self.repo_rhodecode_ui_ids = []
         self.repo_rhodecode_setting_ids = []
 
     def create_repo_rhodecode_ui(
             self, repo, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1(
             '{}{}{}'.format(section, value, repo.repo_id)).hexdigest()
 
         setting = RepoRhodeCodeUi()
         setting.repository_id = repo.repo_id
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_rhodecode_ui(
             self, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1('{}{}'.format(section, value)).hexdigest()
 
         setting = RhodeCodeUi()
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_repo_rhodecode_setting(
             self, repo, name, value, type_, cleanup=True):
         setting = RepoRhodeCodeSetting(
             repo.repo_id, key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_setting_ids.append(setting.app_settings_id)
         return setting
 
     def create_rhodecode_setting(self, name, value, type_, cleanup=True):
         setting = RhodeCodeSetting(key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_setting_ids.append(setting.app_settings_id)
 
         return setting
 
     def cleanup(self):
         for id_ in self.rhodecode_ui_ids:
             setting = RhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.rhodecode_setting_ids:
             setting = RhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_ui_ids:
             setting = RepoRhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_setting_ids:
             setting = RepoRhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         Session().commit()
 
 
 @pytest.fixture
 def no_notifications(request):
     notification_patcher = mock.patch(
         'rhodecode.model.notification.NotificationModel.create')
     notification_patcher.start()
     request.addfinalizer(notification_patcher.stop)
 
 
 @pytest.fixture
 def silence_action_logger(request):
     notification_patcher = mock.patch(
         'rhodecode.lib.utils.action_logger')
     notification_patcher.start()
     request.addfinalizer(notification_patcher.stop)
 
 
 @pytest.fixture(scope='session')
 def repeat(request):
     """
     The number of repetitions is based on this fixture.
 
     Slower calls may divide it by 10 or 100. It is chosen in a way so that the
     tests are not too slow in our default test suite.
     """
     return request.config.getoption('--repeat')
 
 
 @pytest.fixture
 def rhodecode_fixtures():
     return Fixture()
 
 
 @pytest.fixture
 def request_stub():
     """
     Stub request object.
     """
     request = pyramid.testing.DummyRequest()
     request.scheme = 'https'
     return request
 
 
 @pytest.fixture
 def config_stub(request, request_stub):
     """
     Set up pyramid.testing and return the Configurator.
     """
     config = pyramid.testing.setUp(request=request_stub)
 
     @request.addfinalizer
     def cleanup():
         pyramid.testing.tearDown()
 
     return config
 
 
 @pytest.fixture
 def StubIntegrationType():
     class _StubIntegrationType(IntegrationTypeBase):
         """ Test integration type class """
 
         key = 'test'
         display_name = 'Test integration type'
         description = 'A test integration type for testing'
         icon = 'test_icon_html_image'
 
         def __init__(self, settings):
             super(_StubIntegrationType, self).__init__(settings)
             self.sent_events = [] # for testing
 
         def send_event(self, event):
             self.sent_events.append(event)
 
         def settings_schema(self):
             class SettingsSchema(colander.Schema):
                 test_string_field = colander.SchemaNode(
                     colander.String(),
                     missing=colander.required,
                     title='test string field',
                 )
                 test_int_field = colander.SchemaNode(
                     colander.Int(),
                     title='some integer setting',
                 )
             return SettingsSchema()
 
 
     integration_type_registry.register_integration_type(_StubIntegrationType)
     return _StubIntegrationType
 
 @pytest.fixture
 def stub_integration_settings():
     return {
         'test_string_field': 'some data',
         'test_int_field': 100,
     }
 
 
 @pytest.fixture
 def repo_integration_stub(request, repo_stub, StubIntegrationType,
         stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test repo integration',
         repo=repo_stub, repo_group=None, child_repos_only=None)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def repogroup_integration_stub(request, test_repo_group, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test repogroup integration',
         repo=None, repo_group=test_repo_group, child_repos_only=True)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def repogroup_recursive_integration_stub(request, test_repo_group,
     StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test recursive repogroup integration',
         repo=None, repo_group=test_repo_group, child_repos_only=False)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def global_integration_stub(request, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test global integration',
         repo=None, repo_group=None, child_repos_only=None)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def root_repos_integration_stub(request, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test global integration',
         repo=None, repo_group=None, child_repos_only=True)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def local_dt_to_utc():
     def _factory(dt):
         return dt.replace(tzinfo=dateutil.tz.tzlocal()).astimezone(
             dateutil.tz.tzutc()).replace(tzinfo=None)
     return _factory

rhodecode/tests/vcs/test_git.py

@@ -1,1242 +1,1269 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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
-)
+    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.base import BackendTestMixin
 
 
 pytestmark = pytest.mark.backends("git")
 
 
 def repo_path_generator():
     """
     Return a different path to be used for cloning repos.
     """
     i = 0
     while True:
         i += 1
         yield '%s-%d' % (TEST_GIT_REPO_CLONE, i)
 
 
 REPO_PATH_GENERATOR = repo_path_generator()
 
 
 class TestGitRepository:
 
     # pylint: disable=protected-access
 
     def __check_for_existing_repo(self):
         if os.path.exists(TEST_GIT_REPO_CLONE):
             self.fail('Cannot test git clone repo as location %s already '
                       'exists. You should manually remove it first.'
                       % TEST_GIT_REPO_CLONE)
 
     @pytest.fixture(autouse=True)
     def prepare(self, request, pylonsapp):
         self.repo = GitRepository(TEST_GIT_REPO, bare=True)
 
     def get_clone_repo(self):
         """
         Return a non bare clone of the base repo.
         """
         clone_path = next(REPO_PATH_GENERATOR)
         repo_clone = GitRepository(
             clone_path, create=True, src_url=self.repo.path, bare=False)
 
         return repo_clone
 
     def get_empty_repo(self, bare=False):
         """
         Return a non bare empty repo.
         """
         return GitRepository(next(REPO_PATH_GENERATOR), create=True, bare=bare)
 
     def test_wrong_repo_path(self):
         wrong_repo_path = '/tmp/errorrepo'
         with pytest.raises(RepositoryError):
             GitRepository(wrong_repo_path)
 
     def test_repo_clone(self):
         self.__check_for_existing_repo()
         repo = GitRepository(TEST_GIT_REPO)
         repo_clone = GitRepository(
             TEST_GIT_REPO_CLONE,
             src_url=TEST_GIT_REPO, create=True, update_after_clone=True)
         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):
         repo = GitRepository(TEST_GIT_REPO)
         clone_path = TEST_GIT_REPO_CLONE + '_with_update'
         repo_clone = GitRepository(
             clone_path,
             create=True, src_url=TEST_GIT_REPO, update_after_clone=True)
         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):
         repo = GitRepository(TEST_GIT_REPO)
         clone_path = TEST_GIT_REPO_CLONE + '_without_update'
         repo_clone = GitRepository(
             clone_path,
             create=True, src_url=TEST_GIT_REPO, update_after_clone=False)
         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):
         repo = GitRepository(TEST_GIT_REPO)
         clone_path = TEST_GIT_REPO_CLONE + '_bare.git'
         repo_clone = GitRepository(
             clone_path, create=True, src_url=repo.path, bare=True)
         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()
         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 = set([
             '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):
         repo_clone = self.get_clone_repo()
 
         new_branch = 'new_branch'
         assert repo_clone._current_branch() == 'master'
         assert set(repo_clone.branches) == set(('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) == set(('master', new_branch))
         assert repo_clone._current_branch() == new_branch
 
     def test_checkout(self):
         repo_clone = self.get_clone_repo()
 
         repo_clone._checkout('new_branch', create=True)
         repo_clone._checkout('master')
 
         assert repo_clone._current_branch() == 'master'
 
     def test_checkout_same_branch(self):
         repo_clone = self.get_clone_repo()
 
         repo_clone._checkout('master')
         assert repo_clone._current_branch() == 'master'
 
     def test_checkout_branch_already_exists(self):
         repo_clone = self.get_clone_repo()
 
         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):
         repo = self.get_empty_repo()
         assert repo._current_branch() is None
 
     def test_local_clone(self):
         clone_path = next(REPO_PATH_GENERATOR)
         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):
         source_repo = self.get_clone_repo()
 
         # 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 = next(REPO_PATH_GENERATOR)
         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 = next(REPO_PATH_GENERATOR)
         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):
         target_repo = self.get_empty_repo()
         source_repo = self.get_clone_repo()
 
         # 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):
         target_repo = self.get_empty_repo()
         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):
         target_repo = self.get_empty_repo()
 
         with pytest.raises(RepositoryError):
             target_repo._local_fetch(self.repo.path, 'new_branch')
 
     def test_local_pull(self):
         target_repo = self.get_empty_repo()
         source_repo = self.get_clone_repo()
 
         # 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):
         target_repo = self.get_empty_repo()
         source_repo = self.get_clone_repo()
 
         # 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):
         target_repo = self.get_empty_repo()
 
         # 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):
         target_repo = self.get_empty_repo()
 
         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):
         target_repo = self.get_empty_repo(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):
         target_repo = self.get_clone_repo()
 
         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):
         target_repo = self.get_empty_repo(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, 0755)
 
     def test_local_push_does_not_execute_hook(self):
         target_repo = self.get_empty_repo()
 
         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):
         target_repo = self.get_empty_repo(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(
             'pr2', 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(
             'pr2', Reference('branch', 'master', 'unused'))
         assert os.path.isdir(workspace)
 
     def test_cleanup_merge_workspace(self):
         workspace = self.repo._maybe_prepare_merge_workspace(
             'pr3', Reference('branch', 'master', 'unused'))
         self.repo.cleanup_merge_workspace('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('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'
+
+
 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=0120000),  # 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')
 
     def test_get_diff_runs_git_command_with_hashes(self):
         self.repo.run_git_command = mock.Mock(return_value=['', ''])
         self.repo.get_diff(self.repo[0], self.repo[1])
         self.repo.run_git_command.assert_called_once_with(
             ['diff', '-U3', '--full-index', '--binary', '-p', '-M',
              '--abbrev=40', self.repo._get_commit_id(0),
              self.repo._get_commit_id(1)])
 
     def test_get_diff_runs_git_command_with_str_hashes(self):
         self.repo.run_git_command = mock.Mock(return_value=['', ''])
         self.repo.get_diff(self.repo.EMPTY_COMMIT, self.repo[1])
         self.repo.run_git_command.assert_called_once_with(
             ['show', '-U3', '--full-index', '--binary', '-p', '-M',
              '--abbrev=40', self.repo._get_commit_id(1)])
 
     def test_get_diff_runs_git_command_with_path_if_its_given(self):
         self.repo.run_git_command = mock.Mock(return_value=['', ''])
         self.repo.get_diff(self.repo[0], self.repo[1], 'foo')
         self.repo.run_git_command.assert_called_once_with(
             ['diff', '-U3', '--full-index', '--binary', '-p', '-M',
              '--abbrev=40', self.repo._get_commit_id(0),
              self.repo._get_commit_id(1), '--', 'foo'])
 
 
 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:
 
     def test_returns_git_version(self, pylonsapp):
         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_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_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,1172 +1,1180 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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
 
-import rhodecode.lib.vcs.conf.settings
+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 (
-    CommitError, RepositoryError, VCSError, NodeDoesNotExistError,
-    CommitDoesNotExistError)
+    RepositoryError, VCSError, NodeDoesNotExistError, CommitDoesNotExistError)
 from rhodecode.lib.vcs.nodes import FileNode, NodeKind, NodeState
 from rhodecode.tests import TEST_HG_REPO, TEST_HG_REPO_CLONE
 
 
 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, pylonsapp):
     repo = MercurialRepository(TEST_HG_REPO)
     if request.cls:
         request.cls.repo = repo
     return repo
 
 
 class TestMercurialRepository:
 
     # 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'
         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, update_after_clone=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, update_after_clone=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('pr2', 'unused')
 
         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('pr2', 'unused')
         assert os.path.isdir(workspace)
 
     def test_cleanup_merge_workspace(self):
         workspace = self.repo._maybe_prepare_merge_workspace('pr3', 'unused')
         self.repo.cleanup_merge_workspace('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('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')
         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 = 'test-merge'
 
         merge_response = target_repo.merge(
             target_ref, source_repo, source_ref, workspace,
             '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')
         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 = 'test-merge'
 
         merge_response = target_repo.merge(
             target_ref, source_repo, source_ref, workspace,
             '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', 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 = 'test-merge'
 
         assert len(target_repo._heads(branch='default')) == 2
         expected_merge_response = MergeResponse(
             False, False, None,
             MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS)
         merge_response = target_repo.merge(
             target_ref, source_repo, source_ref, workspace,
             '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')
         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)
         workspace = 'test-merge'
 
         merge_response = target_repo.merge(
             target_ref, source_repo, source_ref, workspace,
             '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_large_file(self):
-        # TODO: valid large file
-        tip = self.repo.get_commit()
-        with pytest.raises(CommitError):
-            tip.get_largefile_node("invalid")
-
     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