git: use a fetch_sync based creation of remote repos.

- skips fragile dulwich code that has problems with large repos
- is in sync with logic that does remote fetch
- is faster and more efficient

rhodecode/api/tests/test_create_pull_request.py

@@ -1,338 +1,342 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.db import User
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN
 from rhodecode.api.tests.utils import build_data, api_call, assert_error
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCreatePullRequestApi(object):
     finalizers = []
 
     def teardown_method(self, method):
         if self.finalizers:
             for finalizer in self.finalizers:
                 finalizer()
             self.finalizers = []
 
     def test_create_with_wrong_data(self):
         required_data = {
             'source_repo': 'tests/source_repo',
             'target_repo': 'tests/target_repo',
             'source_ref': 'branch:default:initial',
             'target_ref': 'branch:default:new-feature',
         }
         for key in required_data:
             data = required_data.copy()
             data.pop(key)
             id_, params = build_data(
                 self.apikey, 'create_pull_request', **data)
             response = api_call(self.app, params)
 
             expected = 'Missing non optional `{}` arg in JSON DATA'.format(key)
             assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_create_with_correct_data(self, backend):
         data = self._prepare_data(backend)
         RepoModel().revoke_user_permission(
             self.source.repo_name, User.DEFAULT_USER)
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = "Created new pull request `{title}`".format(
             title=data['title'])
         result = response.json
+        assert result['error'] == None
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
         assert pull_request.title == data['title']
         assert pull_request.description == data['description']
         assert pull_request.source_ref == data['source_ref']
         assert pull_request.target_ref == data['target_ref']
         assert pull_request.source_repo.repo_name == data['source_repo']
         assert pull_request.target_repo.repo_name == data['target_repo']
         assert pull_request.revisions == [self.commit_ids['change']]
         assert len(pull_request.reviewers) == 1
 
     @pytest.mark.backends("git", "hg")
     def test_create_with_empty_description(self, backend):
         data = self._prepare_data(backend)
         data.pop('description')
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = "Created new pull request `{title}`".format(
             title=data['title'])
         result = response.json
+        assert result['error'] == None
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
         assert pull_request.description == ''
 
     @pytest.mark.backends("git", "hg")
     def test_create_with_empty_title(self, backend):
         data = self._prepare_data(backend)
         data.pop('title')
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         result = response.json
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
         data['ref'] = backend.default_branch_name
         title = '{source_repo}#{ref} to {target_repo}'.format(**data)
         assert pull_request.title == title
 
     @pytest.mark.backends("git", "hg")
     def test_create_with_reviewers_specified_by_names(
             self, backend, no_notifications):
         data = self._prepare_data(backend)
         reviewers = [
             {'username': TEST_USER_REGULAR_LOGIN,
              'reasons': ['{} added manually'.format(TEST_USER_REGULAR_LOGIN)]},
             {'username': TEST_USER_ADMIN_LOGIN,
              'reasons': ['{} added manually'.format(TEST_USER_ADMIN_LOGIN)],
              'mandatory': True},
         ]
         data['reviewers'] = reviewers
 
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
 
         expected_message = "Created new pull request `{title}`".format(
             title=data['title'])
         result = response.json
+        assert result['error'] == None
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
 
         actual_reviewers = []
         for rev in pull_request.reviewers:
             entry = {
                 'username': rev.user.username,
                 'reasons': rev.reasons,
              }
             if rev.mandatory:
                 entry['mandatory'] = rev.mandatory
             actual_reviewers.append(entry)
 
         # default reviewer will be added who is an owner of the repo
         reviewers.append(
             {'username': pull_request.author.username,
              'reasons': [u'Default reviewer', u'Repository owner']},
         )
         assert sorted(actual_reviewers, key=lambda e: e['username']) \
                == sorted(reviewers, key=lambda e: e['username'])
 
     @pytest.mark.backends("git", "hg")
     def test_create_with_reviewers_specified_by_ids(
             self, backend, no_notifications):
         data = self._prepare_data(backend)
         reviewers = [
             {'username': UserModel().get_by_username(
                 TEST_USER_REGULAR_LOGIN).user_id,
              'reasons': ['added manually']},
             {'username': UserModel().get_by_username(
                 TEST_USER_ADMIN_LOGIN).user_id,
              'reasons': ['added manually']},
         ]
 
         data['reviewers'] = reviewers
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
 
         expected_message = "Created new pull request `{title}`".format(
             title=data['title'])
         result = response.json
+        assert result['error'] == None
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
 
         actual_reviewers = []
         for rev in pull_request.reviewers:
             entry = {
                 'username': rev.user.user_id,
                 'reasons': rev.reasons,
              }
             if rev.mandatory:
                 entry['mandatory'] = rev.mandatory
             actual_reviewers.append(entry)
         # default reviewer will be added who is an owner of the repo
         reviewers.append(
             {'username': pull_request.author.user_id,
              'reasons': [u'Default reviewer', u'Repository owner']},
         )
         assert sorted(actual_reviewers, key=lambda e: e['username']) \
                == sorted(reviewers, key=lambda e: e['username'])
 
     @pytest.mark.backends("git", "hg")
     def test_create_fails_when_the_reviewer_is_not_found(self, backend):
         data = self._prepare_data(backend)
         data['reviewers'] = [{'username': 'somebody'}]
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'user `somebody` does not exist'
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_cannot_create_with_reviewers_in_wrong_format(self, backend):
         data = self._prepare_data(backend)
         reviewers = ','.join([TEST_USER_REGULAR_LOGIN, TEST_USER_ADMIN_LOGIN])
         data['reviewers'] = reviewers
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = {u'': '"test_regular,test_admin" is not iterable'}
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_create_with_no_commit_hashes(self, backend):
         data = self._prepare_data(backend)
         expected_source_ref = data['source_ref']
         expected_target_ref = data['target_ref']
         data['source_ref'] = 'branch:{}'.format(backend.default_branch_name)
         data['target_ref'] = 'branch:{}'.format(backend.default_branch_name)
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = "Created new pull request `{title}`".format(
             title=data['title'])
         result = response.json
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
         assert pull_request.source_ref == expected_source_ref
         assert pull_request.target_ref == expected_target_ref
 
     @pytest.mark.backends("git", "hg")
     @pytest.mark.parametrize("data_key", ["source_repo", "target_repo"])
     def test_create_fails_with_wrong_repo(self, backend, data_key):
         repo_name = 'fake-repo'
         data = self._prepare_data(backend)
         data[data_key] = repo_name
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'repository `{}` does not exist'.format(repo_name)
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
     def test_create_fails_with_non_existing_branch(self, backend, data_key):
         branch_name = 'test-branch'
         data = self._prepare_data(backend)
         data[data_key] = "branch:{}".format(branch_name)
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'The specified value:{type}:`{name}` ' \
                            'does not exist, or is not allowed.'.format(type='branch',
                                                                        name=branch_name)
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
     def test_create_fails_with_ref_in_a_wrong_format(self, backend, data_key):
         data = self._prepare_data(backend)
         ref = 'stange-ref'
         data[data_key] = ref
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = (
             'Ref `{ref}` given in a wrong format. Please check the API'
             ' documentation for more details'.format(ref=ref))
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
     def test_create_fails_with_non_existing_ref(self, backend, data_key):
         commit_id = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa10'
         ref = self._get_full_ref(backend, commit_id)
         data = self._prepare_data(backend)
         data[data_key] = ref
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'Ref `{}` does not exist'.format(ref)
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_create_fails_when_no_revisions(self, backend):
         data = self._prepare_data(backend, source_head='initial')
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'no commits found'
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_create_fails_when_no_permissions(self, backend):
         data = self._prepare_data(backend)
         RepoModel().revoke_user_permission(
             self.source.repo_name, self.test_user)
         RepoModel().revoke_user_permission(
             self.source.repo_name, User.DEFAULT_USER)
 
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'repository `{}` does not exist'.format(
             self.source.repo_name)
         assert_error(id_, expected_message, given=response.body)
 
     def _prepare_data(
             self, backend, source_head='change', target_head='initial'):
         commits = [
             {'message': 'initial'},
             {'message': 'change'},
             {'message': 'new-feature', 'parents': ['initial']},
         ]
         self.commit_ids = backend.create_master_repo(commits)
         self.source = backend.create_repo(heads=[source_head])
         self.target = backend.create_repo(heads=[target_head])
 
         data = {
             'source_repo': self.source.repo_name,
             'target_repo': self.target.repo_name,
             'source_ref': self._get_full_ref(
                 backend, self.commit_ids[source_head]),
             'target_ref': self._get_full_ref(
                 backend, self.commit_ids[target_head]),
             'title': 'Test PR 1',
             'description': 'Test'
         }
         RepoModel().grant_user_permission(
             self.source.repo_name, self.TEST_USER_LOGIN, 'repository.read')
         return data
 
     def _get_full_ref(self, backend, commit_id):
         return 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name, commit_id=commit_id)

rhodecode/lib/celerylib/tasks.py

@@ -1,308 +1,308 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2018 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/
 
 """
 RhodeCode task modules, containing all task that suppose to be run
 by celery daemon
 """
 
 import os
 import time
 
 import rhodecode
 from rhodecode.lib import audit_logger
 from rhodecode.lib.celerylib import get_logger, async_task, RequestContextTask
 from rhodecode.lib.hooks_base import log_create_repository
 from rhodecode.lib.rcmail.smtp_mailer import SmtpMailer
 from rhodecode.lib.utils2 import safe_int, str2bool
 from rhodecode.model.db import Session, IntegrityError, Repository, User, true
 
 
 @async_task(ignore_result=True, base=RequestContextTask)
 def send_email(recipients, subject, body='', html_body='', email_config=None):
     """
     Sends an email with defined parameters from the .ini files.
 
     :param recipients: list of recipients, it this is empty the defined email
         address from field 'email_to' is used instead
     :param subject: subject of the mail
     :param body: body of the mail
     :param html_body: html version of body
     """
     log = get_logger(send_email)
 
     email_config = email_config or rhodecode.CONFIG
 
     mail_server = email_config.get('smtp_server') or None
     if mail_server is None:
         log.error("SMTP server information missing. Sending email failed. "
                   "Make sure that `smtp_server` variable is configured "
                   "inside the .ini file")
         return False
 
     subject = "%s %s" % (email_config.get('email_prefix', ''), subject)
     if not recipients:
         # if recipients are not defined we send to email_config + all admins
         admins = []
         for u in User.query().filter(User.admin == true()).all():
             if u.email:
                 admins.append(u.email)
         recipients = []
         config_email = email_config.get('email_to')
         if config_email:
             recipients += [config_email]
         recipients += admins
 
     mail_from = email_config.get('app_email_from', 'RhodeCode')
     user = email_config.get('smtp_username')
     passwd = email_config.get('smtp_password')
     mail_port = email_config.get('smtp_port')
     tls = str2bool(email_config.get('smtp_use_tls'))
     ssl = str2bool(email_config.get('smtp_use_ssl'))
     debug = str2bool(email_config.get('debug'))
     smtp_auth = email_config.get('smtp_auth')
 
     try:
         m = SmtpMailer(mail_from, user, passwd, mail_server, smtp_auth,
                        mail_port, ssl, tls, debug=debug)
         m.send(recipients, subject, body, html_body)
     except Exception:
         log.exception('Mail sending failed')
         return False
     return True
 
 
 @async_task(ignore_result=True, base=RequestContextTask)
 def create_repo(form_data, cur_user):
     from rhodecode.model.repo import RepoModel
     from rhodecode.model.user import UserModel
     from rhodecode.model.settings import SettingsModel
 
     log = get_logger(create_repo)
 
     cur_user = UserModel()._get_user(cur_user)
     owner = cur_user
 
     repo_name = form_data['repo_name']
     repo_name_full = form_data['repo_name_full']
     repo_type = form_data['repo_type']
     description = form_data['repo_description']
     private = form_data['repo_private']
     clone_uri = form_data.get('clone_uri')
     repo_group = safe_int(form_data['repo_group'])
     landing_rev = form_data['repo_landing_rev']
     copy_fork_permissions = form_data.get('copy_permissions')
     copy_group_permissions = form_data.get('repo_copy_permissions')
     fork_of = form_data.get('fork_parent_id')
     state = form_data.get('repo_state', Repository.STATE_PENDING)
 
     # repo creation defaults, private and repo_type are filled in form
     defs = SettingsModel().get_default_repo_settings(strip_prefix=True)
     enable_statistics = form_data.get(
         'enable_statistics', defs.get('repo_enable_statistics'))
     enable_locking = form_data.get(
         'enable_locking', defs.get('repo_enable_locking'))
     enable_downloads = form_data.get(
         'enable_downloads', defs.get('repo_enable_downloads'))
 
     try:
-        repo = RepoModel()._create_repo(
+        RepoModel()._create_repo(
             repo_name=repo_name_full,
             repo_type=repo_type,
             description=description,
             owner=owner,
             private=private,
             clone_uri=clone_uri,
             repo_group=repo_group,
             landing_rev=landing_rev,
             fork_of=fork_of,
             copy_fork_permissions=copy_fork_permissions,
             copy_group_permissions=copy_group_permissions,
             enable_statistics=enable_statistics,
             enable_locking=enable_locking,
             enable_downloads=enable_downloads,
             state=state
         )
         Session().commit()
 
         # now create this repo on Filesystem
         RepoModel()._create_filesystem_repo(
             repo_name=repo_name,
             repo_type=repo_type,
             repo_group=RepoModel()._get_repo_group(repo_group),
             clone_uri=clone_uri,
         )
         repo = Repository.get_by_repo_name(repo_name_full)
         log_create_repository(created_by=owner.username, **repo.get_dict())
 
         # update repo commit caches initially
         repo.update_commit_cache()
 
         # set new created state
         repo.set_state(Repository.STATE_CREATED)
         repo_id = repo.repo_id
         repo_data = repo.get_api_data()
 
         audit_logger.store(
             'repo.create', action_data={'data': repo_data},
             user=cur_user,
             repo=audit_logger.RepoWrap(repo_name=repo_name, repo_id=repo_id))
 
         Session().commit()
     except Exception as e:
         log.warning('Exception occurred when creating repository, '
                     'doing cleanup...', exc_info=True)
         if isinstance(e, IntegrityError):
             Session().rollback()
 
         # rollback things manually !
         repo = Repository.get_by_repo_name(repo_name_full)
         if repo:
             Repository.delete(repo.repo_id)
             Session().commit()
             RepoModel()._delete_filesystem_repo(repo)
         log.info('Cleanup of repo %s finished', repo_name_full)
         raise
 
     return True
 
 
 @async_task(ignore_result=True, base=RequestContextTask)
 def create_repo_fork(form_data, cur_user):
     """
     Creates a fork of repository using internal VCS methods
     """
     from rhodecode.model.repo import RepoModel
     from rhodecode.model.user import UserModel
 
     log = get_logger(create_repo_fork)
 
     cur_user = UserModel()._get_user(cur_user)
     owner = cur_user
 
     repo_name = form_data['repo_name']  # fork in this case
     repo_name_full = form_data['repo_name_full']
     repo_type = form_data['repo_type']
     description = form_data['description']
     private = form_data['private']
     clone_uri = form_data.get('clone_uri')
     repo_group = safe_int(form_data['repo_group'])
     landing_rev = form_data['landing_rev']
     copy_fork_permissions = form_data.get('copy_permissions')
     fork_id = safe_int(form_data.get('fork_parent_id'))
 
     try:
         fork_of = RepoModel()._get_repo(fork_id)
         RepoModel()._create_repo(
             repo_name=repo_name_full,
             repo_type=repo_type,
             description=description,
             owner=owner,
             private=private,
             clone_uri=clone_uri,
             repo_group=repo_group,
             landing_rev=landing_rev,
             fork_of=fork_of,
             copy_fork_permissions=copy_fork_permissions
         )
 
         Session().commit()
 
         base_path = Repository.base_path()
         source_repo_path = os.path.join(base_path, fork_of.repo_name)
 
         # now create this repo on Filesystem
         RepoModel()._create_filesystem_repo(
             repo_name=repo_name,
             repo_type=repo_type,
             repo_group=RepoModel()._get_repo_group(repo_group),
             clone_uri=source_repo_path,
         )
         repo = Repository.get_by_repo_name(repo_name_full)
         log_create_repository(created_by=owner.username, **repo.get_dict())
 
         # update repo commit caches initially
         config = repo._config
         config.set('extensions', 'largefiles', '')
         repo.update_commit_cache(config=config)
 
         # set new created state
         repo.set_state(Repository.STATE_CREATED)
 
         repo_id = repo.repo_id
         repo_data = repo.get_api_data()
         audit_logger.store(
             'repo.fork', action_data={'data': repo_data},
             user=cur_user,
             repo=audit_logger.RepoWrap(repo_name=repo_name, repo_id=repo_id))
 
         Session().commit()
     except Exception as e:
         log.warning('Exception occurred when forking repository, '
                     'doing cleanup...', exc_info=True)
         if isinstance(e, IntegrityError):
             Session().rollback()
 
         # rollback things manually !
         repo = Repository.get_by_repo_name(repo_name_full)
         if repo:
             Repository.delete(repo.repo_id)
             Session().commit()
             RepoModel()._delete_filesystem_repo(repo)
         log.info('Cleanup of repo %s finished', repo_name_full)
         raise
 
     return True
 
 
 @async_task(ignore_result=True)
 def repo_maintenance(repoid):
     from rhodecode.lib import repo_maintenance as repo_maintenance_lib
     log = get_logger(repo_maintenance)
     repo = Repository.get_by_id_or_repo_name(repoid)
     if repo:
         maintenance = repo_maintenance_lib.RepoMaintenance()
         tasks = maintenance.get_tasks_for_repo(repo)
         log.debug('Executing %s tasks on repo `%s`', tasks, repoid)
         executed_types = maintenance.execute(repo)
         log.debug('Got execution results %s', executed_types)
     else:
         log.debug('Repo `%s` not found or without a clone_url', repoid)
 
 
 @async_task(ignore_result=True)
 def check_for_update():
     from rhodecode.model.update import UpdateModel
     update_url = UpdateModel().get_update_url()
     cur_ver = rhodecode.__version__
 
     try:
         data = UpdateModel().get_update_data(update_url)
         latest = data['versions'][0]
         UpdateModel().store_version(latest['version'])
     except Exception:
         pass
 
 
 @async_task(ignore_result=False)
 def beat_check(*args, **kwargs):
     log = get_logger(beat_check)
     log.info('Got args: %r and kwargs %r', args, kwargs)
     return time.time()

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

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

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

@@ -1,917 +1,924 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2018 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 repository module
 """
 import os
 import logging
 import binascii
 import urllib
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.datelib import (
     date_to_timestamp_plus_offset, utcdate_fromtimestamp, makedate)
 from rhodecode.lib.utils import safe_unicode, safe_str
 from rhodecode.lib.vcs import connection, exceptions
 from rhodecode.lib.vcs.backends.base import (
     BaseRepository, CollectionGenerator, Config, MergeResponse,
     MergeFailureReason, Reference, BasePathPermissionChecker)
 from rhodecode.lib.vcs.backends.hg.commit import MercurialCommit
 from rhodecode.lib.vcs.backends.hg.diff import MercurialDiff
 from rhodecode.lib.vcs.backends.hg.inmemory import MercurialInMemoryCommit
 from rhodecode.lib.vcs.exceptions import (
     EmptyRepositoryError, RepositoryError, TagAlreadyExistError,
     TagDoesNotExistError, CommitDoesNotExistError, SubrepoMergeError)
 from rhodecode.lib.vcs.compat import configparser
 
 hexlify = binascii.hexlify
 nullid = "\0" * 20
 
 log = logging.getLogger(__name__)
 
 
 class MercurialRepository(BaseRepository):
     """
     Mercurial repository backend
     """
     DEFAULT_BRANCH_NAME = 'default'
 
     def __init__(self, repo_path, config=None, create=False, src_url=None,
-                 update_after_clone=False, with_wire=None):
+                 do_workspace_checkout=False, with_wire=None, bare=False):
         """
         Raises RepositoryError if repository could not be find at the given
         ``repo_path``.
 
         :param repo_path: local path of the repository
         :param config: config object containing the repo configuration
         :param create=False: if set to True, would try to create repository if
            it does not exist rather than raising exception
         :param src_url=None: would try to clone repository from given location
-        :param update_after_clone=False: sets update of working copy after
+        :param do_workspace_checkout=False: sets update of working copy after
            making a clone
+        :param bare: not used, compatible with other VCS
         """
 
         self.path = safe_str(os.path.abspath(repo_path))
         # mercurial since 4.4.X requires certain configuration to be present
         # because sometimes we init the repos with config we need to meet
         # special requirements
         self.config = config if config else self.get_default_config(
             default=[('extensions', 'largefiles', '1')])
         self.with_wire = with_wire
 
-        self._init_repo(create, src_url, update_after_clone)
+        self._init_repo(create, src_url, do_workspace_checkout)
 
         # caches
         self._commit_ids = {}
 
     @LazyProperty
     def _remote(self):
         return connection.Hg(self.path, self.config, with_wire=self.with_wire)
 
     @LazyProperty
     def commit_ids(self):
         """
         Returns list of commit ids, in ascending order.  Being lazy
         attribute allows external tools to inject shas from cache.
         """
         commit_ids = self._get_all_commit_ids()
         self._rebuild_cache(commit_ids)
         return commit_ids
 
     def _rebuild_cache(self, commit_ids):
         self._commit_ids = dict((commit_id, index)
                                 for index, commit_id in enumerate(commit_ids))
 
     @LazyProperty
     def branches(self):
         return self._get_branches()
 
     @LazyProperty
     def branches_closed(self):
         return self._get_branches(active=False, closed=True)
 
     @LazyProperty
     def branches_all(self):
         all_branches = {}
         all_branches.update(self.branches)
         all_branches.update(self.branches_closed)
         return all_branches
 
     def _get_branches(self, active=True, closed=False):
         """
         Gets branches for this repository
         Returns only not closed active branches by default
 
         :param active: return also active branches
         :param closed: return also closed branches
 
         """
         if self.is_empty():
             return {}
 
         def get_name(ctx):
             return ctx[0]
 
         _branches = [(safe_unicode(n), hexlify(h),) for n, h in
                      self._remote.branches(active, closed).items()]
 
         return OrderedDict(sorted(_branches, key=get_name, reverse=False))
 
     @LazyProperty
     def tags(self):
         """
         Gets tags for this repository
         """
         return self._get_tags()
 
     def _get_tags(self):
         if self.is_empty():
             return {}
 
         def get_name(ctx):
             return ctx[0]
 
         _tags = [(safe_unicode(n), hexlify(h),) for n, h in
                  self._remote.tags().items()]
 
         return OrderedDict(sorted(_tags, key=get_name, reverse=True))
 
     def tag(self, name, user, commit_id=None, message=None, date=None,
             **kwargs):
         """
         Creates and returns a tag for the given ``commit_id``.
 
         :param name: name for new tag
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param commit_id: commit id for which new tag would be created
         :param message: message of the tag's commit
         :param date: date of tag's commit
 
         :raises TagAlreadyExistError: if tag with same name already exists
         """
         if name in self.tags:
             raise TagAlreadyExistError("Tag %s already exists" % name)
         commit = self.get_commit(commit_id=commit_id)
         local = kwargs.setdefault('local', False)
 
         if message is None:
             message = "Added tag %s for commit %s" % (name, commit.short_id)
 
         date, tz = date_to_timestamp_plus_offset(date)
 
         self._remote.tag(
             name, commit.raw_id, message, local, user, date, tz)
         self._remote.invalidate_vcs_cache()
 
         # Reinitialize tags
         self.tags = self._get_tags()
         tag_id = self.tags[name]
 
         return self.get_commit(commit_id=tag_id)
 
     def remove_tag(self, name, user, message=None, date=None):
         """
         Removes tag with the given `name`.
 
         :param name: name of the tag to be removed
         :param user: full username, i.e.: "Joe Doe <[e-mail]>"
         :param message: message of the tag's removal commit
         :param date: date of tag's removal commit
 
         :raises TagDoesNotExistError: if tag with given name does not exists
         """
         if name not in self.tags:
             raise TagDoesNotExistError("Tag %s does not exist" % name)
         if message is None:
             message = "Removed tag %s" % name
         local = False
 
         date, tz = date_to_timestamp_plus_offset(date)
 
         self._remote.tag(name, nullid, message, local, user, date, tz)
         self._remote.invalidate_vcs_cache()
         self.tags = self._get_tags()
 
     @LazyProperty
     def bookmarks(self):
         """
         Gets bookmarks for this repository
         """
         return self._get_bookmarks()
 
     def _get_bookmarks(self):
         if self.is_empty():
             return {}
 
         def get_name(ctx):
             return ctx[0]
 
         _bookmarks = [
             (safe_unicode(n), hexlify(h)) for n, h in
             self._remote.bookmarks().items()]
 
         return OrderedDict(sorted(_bookmarks, key=get_name))
 
     def _get_all_commit_ids(self):
         return self._remote.get_all_commit_ids('visible')
 
     def get_diff(
             self, commit1, commit2, path='', ignore_whitespace=False,
             context=3, path1=None):
         """
         Returns (git like) *diff*, as plain text. Shows changes introduced by
         `commit2` since `commit1`.
 
         :param commit1: Entry point from which diff is shown. Can be
           ``self.EMPTY_COMMIT`` - in this case, patch showing all
           the changes since empty state of the repository until `commit2`
         :param commit2: Until which commit changes should be shown.
         :param ignore_whitespace: If set to ``True``, would not show whitespace
           changes. Defaults to ``False``.
         :param context: How many lines before/after changed lines should be
           shown. Defaults to ``3``.
         """
         self._validate_diff_commits(commit1, commit2)
         if path1 is not None and path1 != path:
             raise ValueError("Diff of two different paths not supported.")
 
         if path:
             file_filter = [self.path, path]
         else:
             file_filter = None
 
         diff = self._remote.diff(
             commit1.raw_id, commit2.raw_id, file_filter=file_filter,
             opt_git=True, opt_ignorews=ignore_whitespace,
             context=context)
         return MercurialDiff(diff)
 
     def strip(self, commit_id, branch=None):
         self._remote.strip(commit_id, update=False, backup="none")
 
         self._remote.invalidate_vcs_cache()
         self.commit_ids = self._get_all_commit_ids()
         self._rebuild_cache(self.commit_ids)
 
     def verify(self):
         verify = self._remote.verify()
 
         self._remote.invalidate_vcs_cache()
         return verify
 
     def get_common_ancestor(self, commit_id1, commit_id2, repo2):
         if commit_id1 == commit_id2:
             return commit_id1
 
         ancestors = self._remote.revs_from_revspec(
             "ancestor(id(%s), id(%s))", commit_id1, commit_id2,
             other_path=repo2.path)
         return repo2[ancestors[0]].raw_id if ancestors else None
 
     def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
         if commit_id1 == commit_id2:
             commits = []
         else:
             if merge:
                 indexes = self._remote.revs_from_revspec(
                     "ancestors(id(%s)) - ancestors(id(%s)) - id(%s)",
                     commit_id2, commit_id1, commit_id1, other_path=repo2.path)
             else:
                 indexes = self._remote.revs_from_revspec(
                     "id(%s)..id(%s) - id(%s)", commit_id1, commit_id2,
                     commit_id1, other_path=repo2.path)
 
             commits = [repo2.get_commit(commit_idx=idx, pre_load=pre_load)
                        for idx in indexes]
 
         return commits
 
     @staticmethod
     def check_url(url, config):
         """
         Function will check given url and try to verify if it's a valid
         link. Sometimes it may happened that mercurial will issue basic
         auth request that can cause whole API to hang when used from python
         or other external calls.
 
         On failures it'll raise urllib2.HTTPError, exception is also thrown
         when the return code is non 200
         """
         # check first if it's not an local url
         if os.path.isdir(url) or url.startswith('file:'):
             return True
 
         # Request the _remote to verify the url
         return connection.Hg.check_url(url, config.serialize())
 
     @staticmethod
     def is_valid_repository(path):
         return os.path.isdir(os.path.join(path, '.hg'))
 
-    def _init_repo(self, create, src_url=None, update_after_clone=False):
+    def _init_repo(self, create, src_url=None, do_workspace_checkout=False):
         """
         Function will check for mercurial repository in given path. If there
         is no repository in that path it will raise an exception unless
         `create` parameter is set to True - in that case repository would
         be created.
 
         If `src_url` is given, would try to clone repository from the
         location at given clone_point. Additionally it'll make update to
-        working copy accordingly to `update_after_clone` flag.
+        working copy accordingly to `do_workspace_checkout` flag.
         """
         if create and os.path.exists(self.path):
             raise RepositoryError(
                 "Cannot create repository at %s, location already exist"
                 % self.path)
 
         if src_url:
             url = str(self._get_url(src_url))
             MercurialRepository.check_url(url, self.config)
 
-            self._remote.clone(url, self.path, update_after_clone)
+            self._remote.clone(url, self.path, do_workspace_checkout)
 
             # Don't try to create if we've already cloned repo
             create = False
 
         if create:
             os.makedirs(self.path, mode=0755)
 
         self._remote.localrepository(create)
 
     @LazyProperty
     def in_memory_commit(self):
         return MercurialInMemoryCommit(self)
 
     @LazyProperty
     def description(self):
         description = self._remote.get_config_value(
             'web', 'description', untrusted=True)
         return safe_unicode(description or self.DEFAULT_DESCRIPTION)
 
     @LazyProperty
     def contact(self):
         contact = (
             self._remote.get_config_value("web", "contact") or
             self._remote.get_config_value("ui", "username"))
         return safe_unicode(contact or self.DEFAULT_CONTACT)
 
     @LazyProperty
     def last_change(self):
         """
         Returns last change made on this repository as
         `datetime.datetime` object.
         """
         try:
             return self.get_commit().date
         except RepositoryError:
             tzoffset = makedate()[1]
             return utcdate_fromtimestamp(self._get_fs_mtime(), tzoffset)
 
     def _get_fs_mtime(self):
         # fallback to filesystem
         cl_path = os.path.join(self.path, '.hg', "00changelog.i")
         st_path = os.path.join(self.path, '.hg', "store")
         if os.path.exists(cl_path):
             return os.stat(cl_path).st_mtime
         else:
             return os.stat(st_path).st_mtime
 
     def _get_url(self, url):
         """
         Returns normalized url. If schema is not given, would fall
         to filesystem
         (``file:///``) schema.
         """
         url = url.encode('utf8')
         if url != 'default' and '://' not in url:
             url = "file:" + urllib.pathname2url(url)
         return url
 
     def get_hook_location(self):
         """
         returns absolute path to location where hooks are stored
         """
         return os.path.join(self.path, '.hg', '.hgrc')
 
     def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
         """
         Returns ``MercurialCommit`` object representing repository's
         commit at the given `commit_id` or `commit_idx`.
         """
         if self.is_empty():
             raise EmptyRepositoryError("There are no commits yet")
 
         if commit_id is not None:
             self._validate_commit_id(commit_id)
             try:
                 idx = self._commit_ids[commit_id]
                 return MercurialCommit(self, commit_id, idx, pre_load=pre_load)
             except KeyError:
                 pass
         elif commit_idx is not None:
             self._validate_commit_idx(commit_idx)
             try:
                 id_ = self.commit_ids[commit_idx]
                 if commit_idx < 0:
                     commit_idx += len(self.commit_ids)
                 return MercurialCommit(
                     self, id_, commit_idx, pre_load=pre_load)
             except IndexError:
                 commit_id = commit_idx
         else:
             commit_id = "tip"
 
         if isinstance(commit_id, unicode):
             commit_id = safe_str(commit_id)
 
         try:
             raw_id, idx = self._remote.lookup(commit_id, both=True)
         except CommitDoesNotExistError:
             msg = "Commit %s does not exist for %s" % (
                 commit_id, self)
             raise CommitDoesNotExistError(msg)
 
         return MercurialCommit(self, raw_id, idx, pre_load=pre_load)
 
     def get_commits(
             self, start_id=None, end_id=None, start_date=None, end_date=None,
             branch_name=None, show_hidden=False, pre_load=None):
         """
         Returns generator of ``MercurialCommit`` objects from start to end
         (both are inclusive)
 
         :param start_id: None, str(commit_id)
         :param end_id: None, str(commit_id)
         :param start_date: if specified, commits with commit date less than
           ``start_date`` would be filtered out from returned set
         :param end_date: if specified, commits with commit date greater than
           ``end_date`` would be filtered out from returned set
         :param branch_name: if specified, commits not reachable from given
           branch would be filtered out from returned set
         :param show_hidden: Show hidden commits such as obsolete or hidden from
             Mercurial evolve
         :raise BranchDoesNotExistError: If given ``branch_name`` does not
             exist.
         :raise CommitDoesNotExistError: If commit for given ``start`` or
           ``end`` could not be found.
         """
         # actually we should check now if it's not an empty repo
         branch_ancestors = False
         if self.is_empty():
             raise EmptyRepositoryError("There are no commits yet")
         self._validate_branch_name(branch_name)
 
         if start_id is not None:
             self._validate_commit_id(start_id)
             c_start = self.get_commit(commit_id=start_id)
             start_pos = self._commit_ids[c_start.raw_id]
         else:
             start_pos = None
 
         if end_id is not None:
             self._validate_commit_id(end_id)
             c_end = self.get_commit(commit_id=end_id)
             end_pos = max(0, self._commit_ids[c_end.raw_id])
         else:
             end_pos = None
 
         if None not in [start_id, end_id] and start_pos > end_pos:
             raise RepositoryError(
                 "Start commit '%s' cannot be after end commit '%s'" %
                 (start_id, end_id))
 
         if end_pos is not None:
             end_pos += 1
 
         commit_filter = []
 
         if branch_name and not branch_ancestors:
             commit_filter.append('branch("%s")' % (branch_name,))
         elif branch_name and branch_ancestors:
             commit_filter.append('ancestors(branch("%s"))' % (branch_name,))
 
         if start_date and not end_date:
             commit_filter.append('date(">%s")' % (start_date,))
         if end_date and not start_date:
             commit_filter.append('date("<%s")' % (end_date,))
         if start_date and end_date:
             commit_filter.append(
                 'date(">%s") and date("<%s")' % (start_date, end_date))
 
         if not show_hidden:
             commit_filter.append('not obsolete()')
             commit_filter.append('not hidden()')
 
         # TODO: johbo: Figure out a simpler way for this solution
         collection_generator = CollectionGenerator
         if commit_filter:
             commit_filter = ' and '.join(map(safe_str, commit_filter))
             revisions = self._remote.rev_range([commit_filter])
             collection_generator = MercurialIndexBasedCollectionGenerator
         else:
             revisions = self.commit_ids
 
         if start_pos or end_pos:
             revisions = revisions[start_pos:end_pos]
 
         return collection_generator(self, revisions, pre_load=pre_load)
 
     def pull(self, url, commit_ids=None):
         """
-        Tries to pull changes from external location.
+        Pull changes from external location.
 
         :param commit_ids: Optional. Can be set to a list of commit ids
            which shall be pulled from the other repository.
         """
         url = self._get_url(url)
         self._remote.pull(url, commit_ids=commit_ids)
         self._remote.invalidate_vcs_cache()
 
+    def fetch(self, url, commit_ids=None):
+        """
+        Backward compatibility with GIT fetch==pull
+        """
+        return self.pull(url, commit_ids=commit_ids)
+
     def push(self, url):
         url = self._get_url(url)
         self._remote.sync_push(url)
 
     def _local_clone(self, clone_path):
         """
         Create a local clone of the current repo.
         """
         self._remote.clone(self.path, clone_path, update_after_clone=True,
                            hooks=False)
 
     def _update(self, revision, clean=False):
         """
         Update the working copy to the specified revision.
         """
         log.debug('Doing checkout to commit: `%s` for %s', revision, self)
         self._remote.update(revision, clean=clean)
 
     def _identify(self):
         """
         Return the current state of the working directory.
         """
         return self._remote.identify().strip().rstrip('+')
 
     def _heads(self, branch=None):
         """
         Return the commit ids of the repository heads.
         """
         return self._remote.heads(branch=branch).strip().split(' ')
 
     def _ancestor(self, revision1, revision2):
         """
         Return the common ancestor of the two revisions.
         """
         return self._remote.ancestor(revision1, revision2)
 
     def _local_push(
             self, revision, repository_path, push_branches=False,
             enable_hooks=False):
         """
         Push the given revision to the specified repository.
 
         :param push_branches: allow to create branches in the target repo.
         """
         self._remote.push(
             [revision], repository_path, hooks=enable_hooks,
             push_branches=push_branches)
 
     def _local_merge(self, target_ref, merge_message, user_name, user_email,
                      source_ref, use_rebase=False, dry_run=False):
         """
         Merge the given source_revision into the checked out revision.
 
         Returns the commit id of the merge and a boolean indicating if the
         commit needs to be pushed.
         """
         self._update(target_ref.commit_id)
 
         ancestor = self._ancestor(target_ref.commit_id, source_ref.commit_id)
         is_the_same_branch = self._is_the_same_branch(target_ref, source_ref)
 
         if ancestor == source_ref.commit_id:
             # Nothing to do, the changes were already integrated
             return target_ref.commit_id, False
 
         elif ancestor == target_ref.commit_id and is_the_same_branch:
             # In this case we should force a commit message
             return source_ref.commit_id, True
 
         if use_rebase:
             try:
                 bookmark_name = 'rcbook%s%s' % (source_ref.commit_id,
                                                 target_ref.commit_id)
                 self.bookmark(bookmark_name, revision=source_ref.commit_id)
                 self._remote.rebase(
                     source=source_ref.commit_id, dest=target_ref.commit_id)
                 self._remote.invalidate_vcs_cache()
                 self._update(bookmark_name)
                 return self._identify(), True
             except RepositoryError:
                 # The rebase-abort may raise another exception which 'hides'
                 # the original one, therefore we log it here.
                 log.exception('Error while rebasing shadow repo during merge.')
 
                 # Cleanup any rebase leftovers
                 self._remote.invalidate_vcs_cache()
                 self._remote.rebase(abort=True)
                 self._remote.invalidate_vcs_cache()
                 self._remote.update(clean=True)
                 raise
         else:
             try:
                 self._remote.merge(source_ref.commit_id)
                 self._remote.invalidate_vcs_cache()
                 self._remote.commit(
                     message=safe_str(merge_message),
                     username=safe_str('%s <%s>' % (user_name, user_email)))
                 self._remote.invalidate_vcs_cache()
                 return self._identify(), True
             except RepositoryError:
                 # Cleanup any merge leftovers
                 self._remote.update(clean=True)
                 raise
 
     def _local_close(self, target_ref, user_name, user_email,
                      source_ref, close_message=''):
         """
         Close the branch of the given source_revision
 
         Returns the commit id of the close and a boolean indicating if the
         commit needs to be pushed.
         """
         self._update(source_ref.commit_id)
         message = close_message or "Closing branch: `{}`".format(source_ref.name)
         try:
             self._remote.commit(
                 message=safe_str(message),
                 username=safe_str('%s <%s>' % (user_name, user_email)),
                 close_branch=True)
             self._remote.invalidate_vcs_cache()
             return self._identify(), True
         except RepositoryError:
             # Cleanup any commit leftovers
             self._remote.update(clean=True)
             raise
 
     def _is_the_same_branch(self, target_ref, source_ref):
         return (
             self._get_branch_name(target_ref) ==
             self._get_branch_name(source_ref))
 
     def _get_branch_name(self, ref):
         if ref.type == 'branch':
             return ref.name
         return self._remote.ctx_branch(ref.commit_id)
 
     def _maybe_prepare_merge_workspace(
             self, repo_id, workspace_id, unused_target_ref, unused_source_ref):
         shadow_repository_path = self._get_shadow_repository_path(
             repo_id, workspace_id)
         if not os.path.exists(shadow_repository_path):
             self._local_clone(shadow_repository_path)
             log.debug(
                 'Prepared shadow repository in %s', shadow_repository_path)
 
         return shadow_repository_path
 
     def _merge_repo(self, repo_id, workspace_id, target_ref,
                     source_repo, source_ref, merge_message,
                     merger_name, merger_email, dry_run=False,
                     use_rebase=False, close_branch=False):
 
         log.debug('Executing merge_repo with %s strategy, dry_run mode:%s',
                   'rebase' if use_rebase else 'merge', dry_run)
         if target_ref.commit_id not in self._heads():
             return MergeResponse(
                 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
 
         try:
             if (target_ref.type == 'branch' and
                     len(self._heads(target_ref.name)) != 1):
                 return MergeResponse(
                     False, False, None,
                     MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS)
         except CommitDoesNotExistError:
             log.exception('Failure when looking up branch heads on hg target')
             return MergeResponse(
                 False, False, None, MergeFailureReason.MISSING_TARGET_REF)
 
         shadow_repository_path = self._maybe_prepare_merge_workspace(
             repo_id, workspace_id, target_ref, source_ref)
         shadow_repo = self._get_shadow_instance(shadow_repository_path)
 
         log.debug('Pulling in target reference %s', target_ref)
         self._validate_pull_reference(target_ref)
         shadow_repo._local_pull(self.path, target_ref)
         try:
             log.debug('Pulling in source reference %s', source_ref)
             source_repo._validate_pull_reference(source_ref)
             shadow_repo._local_pull(source_repo.path, source_ref)
         except CommitDoesNotExistError:
             log.exception('Failure when doing local pull on hg shadow repo')
             return MergeResponse(
                 False, False, None, MergeFailureReason.MISSING_SOURCE_REF)
 
         merge_ref = None
         merge_commit_id = None
         close_commit_id = None
         merge_failure_reason = MergeFailureReason.NONE
 
         # enforce that close branch should be used only in case we source from
         # an actual Branch
         close_branch = close_branch and source_ref.type == 'branch'
 
         # don't allow to close branch if source and target are the same
         close_branch = close_branch and source_ref.name != target_ref.name
 
         needs_push_on_close = False
         if close_branch and not use_rebase and not dry_run:
             try:
                 close_commit_id, needs_push_on_close = shadow_repo._local_close(
                     target_ref, merger_name, merger_email, source_ref)
                 merge_possible = True
             except RepositoryError:
                 log.exception(
                     'Failure when doing close branch on hg shadow repo')
                 merge_possible = False
                 merge_failure_reason = MergeFailureReason.MERGE_FAILED
         else:
             merge_possible = True
 
         needs_push = False
         if merge_possible:
             try:
                 merge_commit_id, needs_push = shadow_repo._local_merge(
                     target_ref, merge_message, merger_name, merger_email,
                     source_ref, use_rebase=use_rebase, dry_run=dry_run)
                 merge_possible = True
 
                 # read the state of the close action, if it
                 # maybe required a push
                 needs_push = needs_push or needs_push_on_close
 
                 # Set a bookmark pointing to the merge commit. This bookmark
                 # may be used to easily identify the last successful merge
                 # commit in the shadow repository.
                 shadow_repo.bookmark('pr-merge', revision=merge_commit_id)
                 merge_ref = Reference('book', 'pr-merge', merge_commit_id)
             except SubrepoMergeError:
                 log.exception(
                     'Subrepo merge error during local merge on hg shadow repo.')
                 merge_possible = False
                 merge_failure_reason = MergeFailureReason.SUBREPO_MERGE_FAILED
                 needs_push = False
             except RepositoryError:
                 log.exception('Failure when doing local merge on hg shadow repo')
                 merge_possible = False
                 merge_failure_reason = MergeFailureReason.MERGE_FAILED
                 needs_push = False
 
         if merge_possible and not dry_run:
             if needs_push:
                 # In case the target is a bookmark, update it, so after pushing
                 # the bookmarks is also updated in the target.
                 if target_ref.type == 'book':
                     shadow_repo.bookmark(
                         target_ref.name, revision=merge_commit_id)
                 try:
                     shadow_repo_with_hooks = self._get_shadow_instance(
                         shadow_repository_path,
                         enable_hooks=True)
                     # This is the actual merge action, we push from shadow
                     # into origin.
                     # Note: the push_branches option will push any new branch
                     # defined in the source repository to the target. This may
                     # be dangerous as branches are permanent in Mercurial.
                     # This feature was requested in issue #441.
                     shadow_repo_with_hooks._local_push(
                         merge_commit_id, self.path, push_branches=True,
                         enable_hooks=True)
 
                     # maybe we also need to push the close_commit_id
                     if close_commit_id:
                         shadow_repo_with_hooks._local_push(
                             close_commit_id, self.path, push_branches=True,
                             enable_hooks=True)
                     merge_succeeded = True
                 except RepositoryError:
                     log.exception(
                         'Failure when doing local push from the shadow '
                         'repository to the target repository.')
                     merge_succeeded = False
                     merge_failure_reason = MergeFailureReason.PUSH_FAILED
             else:
                 merge_succeeded = True
         else:
             merge_succeeded = False
 
         return MergeResponse(
             merge_possible, merge_succeeded, merge_ref, merge_failure_reason)
 
     def _get_shadow_instance(
             self, shadow_repository_path, enable_hooks=False):
         config = self.config.copy()
         if not enable_hooks:
             config.clear_section('hooks')
         return MercurialRepository(shadow_repository_path, config)
 
     def _validate_pull_reference(self, reference):
         if not (reference.name in self.bookmarks or
                 reference.name in self.branches or
                 self.get_commit(reference.commit_id)):
             raise CommitDoesNotExistError(
                 'Unknown branch, bookmark or commit id')
 
     def _local_pull(self, repository_path, reference):
         """
         Fetch a branch, bookmark or commit from a local repository.
         """
         repository_path = os.path.abspath(repository_path)
         if repository_path == self.path:
             raise ValueError('Cannot pull from the same repository')
 
         reference_type_to_option_name = {
             'book': 'bookmark',
             'branch': 'branch',
         }
         option_name = reference_type_to_option_name.get(
             reference.type, 'revision')
 
         if option_name == 'revision':
             ref = reference.commit_id
         else:
             ref = reference.name
 
         options = {option_name: [ref]}
         self._remote.pull_cmd(repository_path, hooks=False, **options)
         self._remote.invalidate_vcs_cache()
 
     def bookmark(self, bookmark, revision=None):
         if isinstance(bookmark, unicode):
             bookmark = safe_str(bookmark)
         self._remote.bookmark(bookmark, revision=revision)
         self._remote.invalidate_vcs_cache()
 
     def get_path_permissions(self, username):
         hgacl_file = os.path.join(self.path, '.hg/hgacl')
 
         def read_patterns(suffix):
             svalue = None
             try:
                 svalue = hgacl.get('narrowhgacl', username + suffix)
             except configparser.NoOptionError:
                 try:
                     svalue = hgacl.get('narrowhgacl', 'default' + suffix)
                 except configparser.NoOptionError:
                     pass
             if not svalue:
                 return None
             result = ['/']
             for pattern in svalue.split():
                 result.append(pattern)
                 if '*' not in pattern and '?' not in pattern:
                     result.append(pattern + '/*')
             return result
 
         if os.path.exists(hgacl_file):
             try:
                 hgacl = configparser.RawConfigParser()
                 hgacl.read(hgacl_file)
 
                 includes = read_patterns('.includes')
                 excludes = read_patterns('.excludes')
                 return BasePathPermissionChecker.create_from_patterns(
                     includes, excludes)
             except BaseException as e:
                 msg = 'Cannot read ACL settings from {} on {}: {}'.format(
                     hgacl_file, self.name, e)
                 raise exceptions.RepositoryRequirementError(msg)
         else:
             return None
 
 
 class MercurialIndexBasedCollectionGenerator(CollectionGenerator):
 
     def _commit_factory(self, commit_id):
         return self.repo.get_commit(
             commit_idx=commit_id, pre_load=self.pre_load)

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

@@ -1,343 +1,343 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2018 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/
 
 """
 SVN repository module
 """
 
 import logging
 import os
 import urllib
 
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.datelib import date_astimestamp
 from rhodecode.lib.utils import safe_str, safe_unicode
 from rhodecode.lib.vcs import connection, path as vcspath
 from rhodecode.lib.vcs.backends import base
 from rhodecode.lib.vcs.backends.svn.commit import (
     SubversionCommit, _date_from_svn_properties)
 from rhodecode.lib.vcs.backends.svn.diff import SubversionDiff
 from rhodecode.lib.vcs.backends.svn.inmemory import SubversionInMemoryCommit
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import (
     CommitDoesNotExistError, EmptyRepositoryError, RepositoryError,
     VCSError, NodeDoesNotExistError)
 
 
 log = logging.getLogger(__name__)
 
 
 class SubversionRepository(base.BaseRepository):
     """
     Subversion backend implementation
 
     .. important::
 
        It is very important to distinguish the commit index and the commit id
        which is assigned by Subversion. The first one is always handled as an
        `int` by this implementation. The commit id assigned by Subversion on
        the other side will always be a `str`.
 
        There is a specific trap since the first commit will have the index
        ``0`` but the svn id will be ``"1"``.
 
     """
 
     # Note: Subversion does not really have a default branch name.
     DEFAULT_BRANCH_NAME = None
 
     contact = base.BaseRepository.DEFAULT_CONTACT
     description = base.BaseRepository.DEFAULT_DESCRIPTION
 
-    def __init__(self, repo_path, config=None, create=False, src_url=None,
+    def __init__(self, repo_path, config=None, create=False, src_url=None, bare=False,
                  **kwargs):
         self.path = safe_str(os.path.abspath(repo_path))
         self.config = config if config else self.get_default_config()
 
         self._init_repo(create, src_url)
 
     @LazyProperty
     def _remote(self):
         return connection.Svn(self.path, self.config)
 
     def _init_repo(self, create, src_url):
         if create and os.path.exists(self.path):
             raise RepositoryError(
                 "Cannot create repository at %s, location already exist"
                 % self.path)
 
         if create:
             self._remote.create_repository(settings.SVN_COMPATIBLE_VERSION)
             if src_url:
                 src_url = _sanitize_url(src_url)
                 self._remote.import_remote_repository(src_url)
         else:
             self._check_path()
 
     @LazyProperty
     def commit_ids(self):
         head = self._remote.lookup(None)
         return [str(r) for r in xrange(1, head + 1)]
 
     @LazyProperty
     def branches(self):
         return self._tags_or_branches('vcs_svn_branch')
 
     @LazyProperty
     def branches_closed(self):
         return {}
 
     @LazyProperty
     def bookmarks(self):
         return {}
 
     @LazyProperty
     def branches_all(self):
         # TODO: johbo: Implement proper branch support
         all_branches = {}
         all_branches.update(self.branches)
         all_branches.update(self.branches_closed)
         return all_branches
 
     @LazyProperty
     def tags(self):
         return self._tags_or_branches('vcs_svn_tag')
 
     def _tags_or_branches(self, config_section):
         found_items = {}
 
         if self.is_empty():
             return {}
 
         for pattern in self._patterns_from_section(config_section):
             pattern = vcspath.sanitize(pattern)
             tip = self.get_commit()
             try:
                 if pattern.endswith('*'):
                     basedir = tip.get_node(vcspath.dirname(pattern))
                     directories = basedir.dirs
                 else:
                     directories = (tip.get_node(pattern), )
             except NodeDoesNotExistError:
                 continue
             found_items.update(
                 (safe_unicode(n.path),
                  self.commit_ids[-1])
                 for n in directories)
 
         def get_name(item):
             return item[0]
 
         return OrderedDict(sorted(found_items.items(), key=get_name))
 
     def _patterns_from_section(self, section):
         return (pattern for key, pattern in self.config.items(section))
 
     def get_common_ancestor(self, commit_id1, commit_id2, repo2):
         if self != repo2:
             raise ValueError(
                 "Subversion does not support getting common ancestor of"
                 " different repositories.")
 
         if int(commit_id1) < int(commit_id2):
             return commit_id1
         return commit_id2
 
     def verify(self):
         verify = self._remote.verify()
 
         self._remote.invalidate_vcs_cache()
         return verify
 
     def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
         # TODO: johbo: Implement better comparison, this is a very naive
         # version which does not allow to compare branches, tags or folders
         # at all.
         if repo2 != self:
             raise ValueError(
                 "Subversion does not support comparison of of different "
                 "repositories.")
 
         if commit_id1 == commit_id2:
             return []
 
         commit_idx1 = self._get_commit_idx(commit_id1)
         commit_idx2 = self._get_commit_idx(commit_id2)
 
         commits = [
             self.get_commit(commit_idx=idx)
             for idx in range(commit_idx1 + 1, commit_idx2 + 1)]
 
         return commits
 
     def _get_commit_idx(self, commit_id):
         try:
             svn_rev = int(commit_id)
         except:
             # TODO: johbo: this might be only one case, HEAD, check this
             svn_rev = self._remote.lookup(commit_id)
         commit_idx = svn_rev - 1
         if commit_idx >= len(self.commit_ids):
             raise CommitDoesNotExistError(
                 "Commit at index %s does not exist." % (commit_idx, ))
         return commit_idx
 
     @staticmethod
     def check_url(url, config):
         """
         Check if `url` is a valid source to import a Subversion repository.
         """
         # convert to URL if it's a local directory
         if os.path.isdir(url):
             url = 'file://' + urllib.pathname2url(url)
         return connection.Svn.check_url(url, config.serialize())
 
     @staticmethod
     def is_valid_repository(path):
         try:
             SubversionRepository(path)
             return True
         except VCSError:
             pass
         return False
 
     def _check_path(self):
         if not os.path.exists(self.path):
             raise VCSError('Path "%s" does not exist!' % (self.path, ))
         if not self._remote.is_path_valid_repository(self.path):
             raise VCSError(
                 'Path "%s" does not contain a Subversion repository' %
                 (self.path, ))
 
     @LazyProperty
     def last_change(self):
         """
         Returns last change made on this repository as
         `datetime.datetime` object.
         """
         # Subversion always has a first commit which has id "0" and contains
         # what we are looking for.
         last_id = len(self.commit_ids)
         properties = self._remote.revision_properties(last_id)
         return _date_from_svn_properties(properties)
 
     @LazyProperty
     def in_memory_commit(self):
         return SubversionInMemoryCommit(self)
 
     def get_hook_location(self):
         """
         returns absolute path to location where hooks are stored
         """
         return os.path.join(self.path, 'hooks')
 
     def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
         if self.is_empty():
             raise EmptyRepositoryError("There are no commits yet")
         if commit_id is not None:
             self._validate_commit_id(commit_id)
         elif commit_idx is not None:
             self._validate_commit_idx(commit_idx)
             try:
                 commit_id = self.commit_ids[commit_idx]
             except IndexError:
                 raise CommitDoesNotExistError
 
         commit_id = self._sanitize_commit_id(commit_id)
         commit = SubversionCommit(repository=self, commit_id=commit_id)
         return commit
 
     def get_commits(
             self, start_id=None, end_id=None, start_date=None, end_date=None,
             branch_name=None, show_hidden=False, pre_load=None):
         if self.is_empty():
             raise EmptyRepositoryError("There are no commit_ids yet")
         self._validate_branch_name(branch_name)
 
         if start_id is not None:
             self._validate_commit_id(start_id)
         if end_id is not None:
             self._validate_commit_id(end_id)
 
         start_raw_id = self._sanitize_commit_id(start_id)
         start_pos = self.commit_ids.index(start_raw_id) if start_id else None
         end_raw_id = self._sanitize_commit_id(end_id)
         end_pos = max(0, self.commit_ids.index(end_raw_id)) if end_id else None
 
         if None not in [start_id, end_id] and start_pos > end_pos:
             raise RepositoryError(
                 "Start commit '%s' cannot be after end commit '%s'" %
                 (start_id, end_id))
         if end_pos is not None:
             end_pos += 1
 
         # Date based filtering
         if start_date or end_date:
             start_raw_id, end_raw_id = self._remote.lookup_interval(
                 date_astimestamp(start_date) if start_date else None,
                 date_astimestamp(end_date) if end_date else None)
             start_pos = start_raw_id - 1
             end_pos = end_raw_id
 
         commit_ids = self.commit_ids
 
         # TODO: johbo: Reconsider impact of DEFAULT_BRANCH_NAME here
         if branch_name not in [None, self.DEFAULT_BRANCH_NAME]:
             svn_rev = long(self.commit_ids[-1])
             commit_ids = self._remote.node_history(
                 path=branch_name, revision=svn_rev, limit=None)
             commit_ids = [str(i) for i in reversed(commit_ids)]
 
         if start_pos or end_pos:
             commit_ids = commit_ids[start_pos:end_pos]
         return base.CollectionGenerator(self, commit_ids, pre_load=pre_load)
 
     def _sanitize_commit_id(self, commit_id):
         if commit_id and commit_id.isdigit():
             if int(commit_id) <= len(self.commit_ids):
                 return commit_id
             else:
                 raise CommitDoesNotExistError(
                     "Commit %s does not exist." % (commit_id, ))
         if commit_id not in [
                 None, 'HEAD', 'tip', self.DEFAULT_BRANCH_NAME]:
             raise CommitDoesNotExistError(
                 "Commit id %s not understood." % (commit_id, ))
         svn_rev = self._remote.lookup('HEAD')
         return str(svn_rev)
 
     def get_diff(
             self, commit1, commit2, path=None, ignore_whitespace=False,
             context=3, path1=None):
         self._validate_diff_commits(commit1, commit2)
         svn_rev1 = long(commit1.raw_id)
         svn_rev2 = long(commit2.raw_id)
         diff = self._remote.diff(
             svn_rev1, svn_rev2, path1=path1, path2=path,
             ignore_whitespace=ignore_whitespace, context=context)
         return SubversionDiff(diff)
 
 
 def _sanitize_url(url):
     if '://' not in url:
         url = 'file://' + urllib.pathname2url(url)
     return url

rhodecode/model/scm.py

@@ -1,833 +1,833 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 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/
 
 """
 Scm model for RhodeCode
 """
 
 import os.path
 import traceback
 import logging
 import cStringIO
 
 from sqlalchemy import func
 from zope.cachedescriptors.property import Lazy as LazyProperty
 
 import rhodecode
 from rhodecode.lib.vcs import get_backend
 from rhodecode.lib.vcs.exceptions import RepositoryError, NodeNotChangedError
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib import helpers as h, rc_cache
 from rhodecode.lib.auth import (
     HasRepoPermissionAny, HasRepoGroupPermissionAny,
     HasUserGroupPermissionAny)
 from rhodecode.lib.exceptions import NonRelativePathError, IMCCommitError
 from rhodecode.lib import hooks_utils
 from rhodecode.lib.utils import (
     get_filesystem_repos, make_db_config)
 from rhodecode.lib.utils2 import (safe_str, safe_unicode)
 from rhodecode.lib.system_info import get_system_info
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
     Repository, CacheKey, UserFollowing, UserLog, User, RepoGroup,
     PullRequest)
 from rhodecode.model.settings import VcsSettingsModel
 from rhodecode.model.validation_schema.validators import url_validator, InvalidCloneUrl
 
 log = logging.getLogger(__name__)
 
 
 class UserTemp(object):
     def __init__(self, user_id):
         self.user_id = user_id
 
     def __repr__(self):
         return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)
 
 
 class RepoTemp(object):
     def __init__(self, repo_id):
         self.repo_id = repo_id
 
     def __repr__(self):
         return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)
 
 
 class SimpleCachedRepoList(object):
     """
     Lighter version of of iteration of repos without the scm initialisation,
     and with cache usage
     """
     def __init__(self, db_repo_list, repos_path, order_by=None, perm_set=None):
         self.db_repo_list = db_repo_list
         self.repos_path = repos_path
         self.order_by = order_by
         self.reversed = (order_by or '').startswith('-')
         if not perm_set:
             perm_set = ['repository.read', 'repository.write',
                         'repository.admin']
         self.perm_set = perm_set
 
     def __len__(self):
         return len(self.db_repo_list)
 
     def __repr__(self):
         return '<%s (%s)>' % (self.__class__.__name__, self.__len__())
 
     def __iter__(self):
         for dbr in self.db_repo_list:
             # check permission at this level
             has_perm = HasRepoPermissionAny(*self.perm_set)(
                 dbr.repo_name, 'SimpleCachedRepoList check')
             if not has_perm:
                 continue
 
             tmp_d = {
                 'name': dbr.repo_name,
                 'dbrepo': dbr.get_dict(),
                 'dbrepo_fork': dbr.fork.get_dict() if dbr.fork else {}
             }
             yield tmp_d
 
 
 class _PermCheckIterator(object):
 
     def __init__(
             self, obj_list, obj_attr, perm_set, perm_checker,
             extra_kwargs=None):
         """
         Creates iterator from given list of objects, additionally
         checking permission for them from perm_set var
 
         :param obj_list: list of db objects
         :param obj_attr: attribute of object to pass into perm_checker
         :param perm_set: list of permissions to check
         :param perm_checker: callable to check permissions against
         """
         self.obj_list = obj_list
         self.obj_attr = obj_attr
         self.perm_set = perm_set
         self.perm_checker = perm_checker
         self.extra_kwargs = extra_kwargs or {}
 
     def __len__(self):
         return len(self.obj_list)
 
     def __repr__(self):
         return '<%s (%s)>' % (self.__class__.__name__, self.__len__())
 
     def __iter__(self):
         checker = self.perm_checker(*self.perm_set)
         for db_obj in self.obj_list:
             # check permission at this level
             name = getattr(db_obj, self.obj_attr, None)
             if not checker(name, self.__class__.__name__, **self.extra_kwargs):
                 continue
 
             yield db_obj
 
 
 class RepoList(_PermCheckIterator):
 
     def __init__(self, db_repo_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = [
                 'repository.read', 'repository.write', 'repository.admin']
 
         super(RepoList, self).__init__(
             obj_list=db_repo_list,
             obj_attr='repo_name', perm_set=perm_set,
             perm_checker=HasRepoPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class RepoGroupList(_PermCheckIterator):
 
     def __init__(self, db_repo_group_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = ['group.read', 'group.write', 'group.admin']
 
         super(RepoGroupList, self).__init__(
             obj_list=db_repo_group_list,
             obj_attr='group_name', perm_set=perm_set,
             perm_checker=HasRepoGroupPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class UserGroupList(_PermCheckIterator):
 
     def __init__(self, db_user_group_list, perm_set=None, extra_kwargs=None):
         if not perm_set:
             perm_set = ['usergroup.read', 'usergroup.write', 'usergroup.admin']
 
         super(UserGroupList, self).__init__(
             obj_list=db_user_group_list,
             obj_attr='users_group_name', perm_set=perm_set,
             perm_checker=HasUserGroupPermissionAny,
             extra_kwargs=extra_kwargs)
 
 
 class ScmModel(BaseModel):
     """
     Generic Scm Model
     """
 
     @LazyProperty
     def repos_path(self):
         """
         Gets the repositories root path from database
         """
 
         settings_model = VcsSettingsModel(sa=self.sa)
         return settings_model.get_repos_location()
 
     def repo_scan(self, repos_path=None):
         """
         Listing of repositories in given path. This path should not be a
         repository itself. Return a dictionary of repository objects
 
         :param repos_path: path to directory containing repositories
         """
 
         if repos_path is None:
             repos_path = self.repos_path
 
         log.info('scanning for repositories in %s', repos_path)
 
         config = make_db_config()
         config.set('extensions', 'largefiles', '')
         repos = {}
 
         for name, path in get_filesystem_repos(repos_path, recursive=True):
             # name need to be decomposed and put back together using the /
             # since this is internal storage separator for rhodecode
             name = Repository.normalize_repo_name(name)
 
             try:
                 if name in repos:
                     raise RepositoryError('Duplicate repository name %s '
                                           'found in %s' % (name, path))
                 elif path[0] in rhodecode.BACKENDS:
                     klass = get_backend(path[0])
                     repos[name] = klass(path[1], config=config)
             except OSError:
                 continue
         log.debug('found %s paths with repositories', len(repos))
         return repos
 
     def get_repos(self, all_repos=None, sort_key=None):
         """
         Get all repositories from db and for each repo create it's
         backend instance and fill that backed with information from database
 
         :param all_repos: list of repository names as strings
             give specific repositories list, good for filtering
 
         :param sort_key: initial sorting of repositories
         """
         if all_repos is None:
             all_repos = self.sa.query(Repository)\
                 .filter(Repository.group_id == None)\
                 .order_by(func.lower(Repository.repo_name)).all()
         repo_iter = SimpleCachedRepoList(
             all_repos, repos_path=self.repos_path, order_by=sort_key)
         return repo_iter
 
     def get_repo_groups(self, all_groups=None):
         if all_groups is None:
             all_groups = RepoGroup.query()\
                 .filter(RepoGroup.group_parent_id == None).all()
         return [x for x in RepoGroupList(all_groups)]
 
     def mark_for_invalidation(self, repo_name, delete=False):
         """
         Mark caches of this repo invalid in the database. `delete` flag
         removes the cache entries
 
         :param repo_name: the repo_name for which caches should be marked
             invalid, or deleted
         :param delete: delete the entry keys instead of setting bool
             flag on them, and also purge caches used by the dogpile
         """
         repo = Repository.get_by_repo_name(repo_name)
 
         if repo:
             invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
                 repo_id=repo.repo_id)
             CacheKey.set_invalidate(invalidation_namespace, delete=delete)
 
             repo_id = repo.repo_id
             config = repo._config
             config.set('extensions', 'largefiles', '')
             repo.update_commit_cache(config=config, cs_cache=None)
             if delete:
                 cache_namespace_uid = 'cache_repo.{}'.format(repo_id)
                 rc_cache.clear_cache_namespace('cache_repo', cache_namespace_uid)
 
     def toggle_following_repo(self, follow_repo_id, user_id):
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repo_id == follow_repo_id)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         if f is not None:
             try:
                 self.sa.delete(f)
                 return
             except Exception:
                 log.error(traceback.format_exc())
                 raise
 
         try:
             f = UserFollowing()
             f.user_id = user_id
             f.follows_repo_id = follow_repo_id
             self.sa.add(f)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def toggle_following_user(self, follow_user_id, user_id):
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user_id == follow_user_id)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         if f is not None:
             try:
                 self.sa.delete(f)
                 return
             except Exception:
                 log.error(traceback.format_exc())
                 raise
 
         try:
             f = UserFollowing()
             f.user_id = user_id
             f.follows_user_id = follow_user_id
             self.sa.add(f)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def is_following_repo(self, repo_name, user_id, cache=False):
         r = self.sa.query(Repository)\
             .filter(Repository.repo_name == repo_name).scalar()
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repository == r)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         return f is not None
 
     def is_following_user(self, username, user_id, cache=False):
         u = User.get_by_username(username)
 
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user == u)\
             .filter(UserFollowing.user_id == user_id).scalar()
 
         return f is not None
 
     def get_followers(self, repo):
         repo = self._get_repo(repo)
 
         return self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repository == repo).count()
 
     def get_forks(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(Repository)\
             .filter(Repository.fork == repo).count()
 
     def get_pull_requests(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(PullRequest)\
             .filter(PullRequest.target_repo == repo)\
             .filter(PullRequest.status != PullRequest.STATUS_CLOSED).count()
 
     def mark_as_fork(self, repo, fork, user):
         repo = self._get_repo(repo)
         fork = self._get_repo(fork)
         if fork and repo.repo_id == fork.repo_id:
             raise Exception("Cannot set repository as fork of itself")
 
         if fork and repo.repo_type != fork.repo_type:
             raise RepositoryError(
                 "Cannot set repository as fork of repository with other type")
 
         repo.fork = fork
         self.sa.add(repo)
         return repo
 
     def pull_changes(self, repo, username, remote_uri=None, validate_uri=True):
         dbrepo = self._get_repo(repo)
         remote_uri = remote_uri or dbrepo.clone_uri
         if not remote_uri:
             raise Exception("This repository doesn't have a clone uri")
 
         repo = dbrepo.scm_instance(cache=False)
         repo.config.clear_section('hooks')
 
         try:
             # NOTE(marcink): add extra validation so we skip invalid urls
             # this is due this tasks can be executed via scheduler without
             # proper validation of remote_uri
             if validate_uri:
                 config = make_db_config(clear_session=False)
                 url_validator(remote_uri, dbrepo.repo_type, config)
         except InvalidCloneUrl:
             raise
 
         repo_name = dbrepo.repo_name
         try:
             # TODO: we need to make sure those operations call proper hooks !
-            repo.pull(remote_uri)
+            repo.fetch(remote_uri)
 
             self.mark_for_invalidation(repo_name)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def push_changes(self, repo, username, remote_uri=None, validate_uri=True):
         dbrepo = self._get_repo(repo)
         remote_uri = remote_uri or dbrepo.push_uri
         if not remote_uri:
             raise Exception("This repository doesn't have a clone uri")
 
         repo = dbrepo.scm_instance(cache=False)
         repo.config.clear_section('hooks')
 
         try:
             # NOTE(marcink): add extra validation so we skip invalid urls
             # this is due this tasks can be executed via scheduler without
             # proper validation of remote_uri
             if validate_uri:
                 config = make_db_config(clear_session=False)
                 url_validator(remote_uri, dbrepo.repo_type, config)
         except InvalidCloneUrl:
             raise
 
         try:
             repo.push(remote_uri)
         except Exception:
             log.error(traceback.format_exc())
             raise
 
     def commit_change(self, repo, repo_name, commit, user, author, message,
                       content, f_path):
         """
         Commits changes
 
         :param repo: SCM instance
 
         """
         user = self._get_user(user)
 
         # decoding here will force that we have proper encoded values
         # in any other case this will throw exceptions and deny commit
         content = safe_str(content)
         path = safe_str(f_path)
         # message and author needs to be unicode
         # proper backend should then translate that into required type
         message = safe_unicode(message)
         author = safe_unicode(author)
         imc = repo.in_memory_commit
         imc.change(FileNode(path, content, mode=commit.get_file_mode(f_path)))
         try:
             # TODO: handle pre-push action !
             tip = imc.commit(
                 message=message, author=author, parents=[commit],
                 branch=commit.branch)
         except Exception as e:
             log.error(traceback.format_exc())
             raise IMCCommitError(str(e))
         finally:
             # always clear caches, if commit fails we want fresh object also
             self.mark_for_invalidation(repo_name)
 
         # We trigger the post-push action
         hooks_utils.trigger_post_push_hook(
             username=user.username, action='push_local', repo_name=repo_name,
             repo_alias=repo.alias, commit_ids=[tip.raw_id])
         return tip
 
     def _sanitize_path(self, f_path):
         if f_path.startswith('/') or f_path.startswith('./') or '../' in f_path:
             raise NonRelativePathError('%s is not an relative path' % f_path)
         if f_path:
             f_path = os.path.normpath(f_path)
         return f_path
 
     def get_dirnode_metadata(self, request, commit, dir_node):
         if not dir_node.is_dir():
             return []
 
         data = []
         for node in dir_node:
             if not node.is_file():
                 # we skip file-nodes
                 continue
 
             last_commit = node.last_commit
             last_commit_date = last_commit.date
             data.append({
                 'name': node.name,
                 'size': h.format_byte_size_binary(node.size),
                 'modified_at': h.format_date(last_commit_date),
                 'modified_ts': last_commit_date.isoformat(),
                 'revision': last_commit.revision,
                 'short_id': last_commit.short_id,
                 'message': h.escape(last_commit.message),
                 'author': h.escape(last_commit.author),
                 'user_profile': h.gravatar_with_user(
                     request, last_commit.author),
             })
 
         return data
 
     def get_nodes(self, repo_name, commit_id, root_path='/', flat=True,
                   extended_info=False, content=False, max_file_bytes=None):
         """
         recursive walk in root dir and return a set of all path in that dir
         based on repository walk function
 
         :param repo_name: name of repository
         :param commit_id: commit id for which to list nodes
         :param root_path: root path to list
         :param flat: return as a list, if False returns a dict with description
         :param max_file_bytes: will not return file contents over this limit
 
         """
         _files = list()
         _dirs = list()
         try:
             _repo = self._get_repo(repo_name)
             commit = _repo.scm_instance().get_commit(commit_id=commit_id)
             root_path = root_path.lstrip('/')
             for __, dirs, files in commit.walk(root_path):
                 for f in files:
                     _content = None
                     _data = f.unicode_path
                     over_size_limit = (max_file_bytes is not None
                                        and f.size > max_file_bytes)
 
                     if not flat:
                         _data = {
                             "name": h.escape(f.unicode_path),
                             "type": "file",
                             }
                         if extended_info:
                             _data.update({
                                 "md5": f.md5,
                                 "binary": f.is_binary,
                                 "size": f.size,
                                 "extension": f.extension,
                                 "mimetype": f.mimetype,
                                 "lines": f.lines()[0]
                             })
 
                         if content:
                             full_content = None
                             if not f.is_binary and not over_size_limit:
                                 full_content = safe_str(f.content)
 
                             _data.update({
                                 "content": full_content,
                             })
                     _files.append(_data)
                 for d in dirs:
                     _data = d.unicode_path
                     if not flat:
                         _data = {
                             "name": h.escape(d.unicode_path),
                             "type": "dir",
                             }
                     if extended_info:
                         _data.update({
                             "md5": None,
                             "binary": None,
                             "size": None,
                             "extension": None,
                         })
                     if content:
                         _data.update({
                             "content": None
                         })
                     _dirs.append(_data)
         except RepositoryError:
             log.debug("Exception in get_nodes", exc_info=True)
             raise
 
         return _dirs, _files
 
     def create_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         """
         Commits given multiple nodes into repo
 
         :param user: RhodeCode User object or user_id, the commiter
         :param repo: RhodeCode Repository object
         :param message: commit message
         :param nodes: mapping {filename:{'content':content},...}
         :param parent_commit: parent commit, can be empty than it's
            initial commit
         :param author: author of commit, cna be different that commiter
            only for git
         :param trigger_push_hook: trigger push hooks
 
         :returns: new commited commit
         """
 
         user = self._get_user(user)
         scm_instance = repo.scm_instance(cache=False)
 
         processed_nodes = []
         for f_path in nodes:
             f_path = self._sanitize_path(f_path)
             content = nodes[f_path]['content']
             f_path = safe_str(f_path)
             # decoding here will force that we have proper encoded values
             # in any other case this will throw exceptions and deny commit
             if isinstance(content, (basestring,)):
                 content = safe_str(content)
             elif isinstance(content, (file, cStringIO.OutputType,)):
                 content = content.read()
             else:
                 raise Exception('Content is of unrecognized type %s' % (
                     type(content)
                 ))
             processed_nodes.append((f_path, content))
 
         message = safe_unicode(message)
         commiter = user.full_contact
         author = safe_unicode(author) if author else commiter
 
         imc = scm_instance.in_memory_commit
 
         if not parent_commit:
             parent_commit = EmptyCommit(alias=scm_instance.alias)
 
         if isinstance(parent_commit, EmptyCommit):
             # EmptyCommit means we we're editing empty repository
             parents = None
         else:
             parents = [parent_commit]
         # add multiple nodes
         for path, content in processed_nodes:
             imc.add(FileNode(path, content=content))
         # TODO: handle pre push scenario
         tip = imc.commit(message=message,
                          author=author,
                          parents=parents,
                          branch=parent_commit.branch)
 
         self.mark_for_invalidation(repo.repo_name)
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local',
                 repo_name=repo.repo_name, repo_alias=scm_instance.alias,
                 commit_ids=[tip.raw_id])
         return tip
 
     def update_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         user = self._get_user(user)
         scm_instance = repo.scm_instance(cache=False)
 
         message = safe_unicode(message)
         commiter = user.full_contact
         author = safe_unicode(author) if author else commiter
 
         imc = scm_instance.in_memory_commit
 
         if not parent_commit:
             parent_commit = EmptyCommit(alias=scm_instance.alias)
 
         if isinstance(parent_commit, EmptyCommit):
             # EmptyCommit means we we're editing empty repository
             parents = None
         else:
             parents = [parent_commit]
 
         # add multiple nodes
         for _filename, data in nodes.items():
             # new filename, can be renamed from the old one, also sanitaze
             # the path for any hack around relative paths like ../../ etc.
             filename = self._sanitize_path(data['filename'])
             old_filename = self._sanitize_path(_filename)
             content = data['content']
 
             filenode = FileNode(old_filename, content=content)
             op = data['op']
             if op == 'add':
                 imc.add(filenode)
             elif op == 'del':
                 imc.remove(filenode)
             elif op == 'mod':
                 if filename != old_filename:
                     # TODO: handle renames more efficient, needs vcs lib
                     # changes
                     imc.remove(filenode)
                     imc.add(FileNode(filename, content=content))
                 else:
                     imc.change(filenode)
 
         try:
             # TODO: handle pre push scenario
             # commit changes
             tip = imc.commit(message=message,
                              author=author,
                              parents=parents,
                              branch=parent_commit.branch)
         except NodeNotChangedError:
             raise
         except Exception as e:
             log.exception("Unexpected exception during call to imc.commit")
             raise IMCCommitError(str(e))
         finally:
             # always clear caches, if commit fails we want fresh object also
             self.mark_for_invalidation(repo.repo_name)
 
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local',
                 repo_name=repo.repo_name, repo_alias=scm_instance.alias,
                 commit_ids=[tip.raw_id])
 
     def delete_nodes(self, user, repo, message, nodes, parent_commit=None,
                      author=None, trigger_push_hook=True):
         """
         Deletes given multiple nodes into `repo`
 
         :param user: RhodeCode User object or user_id, the committer
         :param repo: RhodeCode Repository object
         :param message: commit message
         :param nodes: mapping {filename:{'content':content},...}
         :param parent_commit: parent commit, can be empty than it's initial
            commit
         :param author: author of commit, cna be different that commiter only
            for git
         :param trigger_push_hook: trigger push hooks
 
         :returns: new commit after deletion
         """
 
         user = self._get_user(user)
         scm_instance = repo.scm_instance(cache=False)
 
         processed_nodes = []
         for f_path in nodes:
             f_path = self._sanitize_path(f_path)
             # content can be empty but for compatabilty it allows same dicts
             # structure as add_nodes
             content = nodes[f_path].get('content')
             processed_nodes.append((f_path, content))
 
         message = safe_unicode(message)
         commiter = user.full_contact
         author = safe_unicode(author) if author else commiter
 
         imc = scm_instance.in_memory_commit
 
         if not parent_commit:
             parent_commit = EmptyCommit(alias=scm_instance.alias)
 
         if isinstance(parent_commit, EmptyCommit):
             # EmptyCommit means we we're editing empty repository
             parents = None
         else:
             parents = [parent_commit]
         # add multiple nodes
         for path, content in processed_nodes:
             imc.remove(FileNode(path, content=content))
 
         # TODO: handle pre push scenario
         tip = imc.commit(message=message,
                          author=author,
                          parents=parents,
                          branch=parent_commit.branch)
 
         self.mark_for_invalidation(repo.repo_name)
         if trigger_push_hook:
             hooks_utils.trigger_post_push_hook(
                 username=user.username, action='push_local',
                 repo_name=repo.repo_name, repo_alias=scm_instance.alias,
                 commit_ids=[tip.raw_id])
         return tip
 
     def strip(self, repo, commit_id, branch):
         scm_instance = repo.scm_instance(cache=False)
         scm_instance.config.clear_section('hooks')
         scm_instance.strip(commit_id, branch)
         self.mark_for_invalidation(repo.repo_name)
 
     def get_unread_journal(self):
         return self.sa.query(UserLog).count()
 
     def get_repo_landing_revs(self, translator, repo=None):
         """
         Generates select option with tags branches and bookmarks (for hg only)
         grouped by type
 
         :param repo:
         """
         _ = translator
         repo = self._get_repo(repo)
 
         hist_l = [
             ['rev:tip', _('latest tip')]
         ]
         choices = [
             'rev:tip'
         ]
 
         if not repo:
             return choices, hist_l
 
         repo = repo.scm_instance()
 
         branches_group = (
             [(u'branch:%s' % safe_unicode(b), safe_unicode(b))
                 for b in repo.branches],
             _("Branches"))
         hist_l.append(branches_group)
         choices.extend([x[0] for x in branches_group[0]])
 
         if repo.alias == 'hg':
             bookmarks_group = (
                 [(u'book:%s' % safe_unicode(b), safe_unicode(b))
                     for b in repo.bookmarks],
                 _("Bookmarks"))
             hist_l.append(bookmarks_group)
             choices.extend([x[0] for x in bookmarks_group[0]])
 
         tags_group = (
             [(u'tag:%s' % safe_unicode(t), safe_unicode(t))
                 for t in repo.tags],
             _("Tags"))
         hist_l.append(tags_group)
         choices.extend([x[0] for x in tags_group[0]])
 
         return choices, hist_l
 
     def get_server_info(self, environ=None):
         server_info = get_system_info(environ)
         return server_info

rhodecode/tests/plugin.py

@@ -1,1865 +1,1867 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 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 functools
 
 import mock
 import pyramid.testing
 import pytest
 import colander
 import requests
 import pyramid.paster
 
 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, set_anonymous_access
 from rhodecode.tests.fixture import Fixture
 from rhodecode.config import utils as config_utils
 
 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):
     from rhodecode.config import patches
 
 
 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 'example.com:80'
 
 
 @pytest.fixture
 def http_host_only_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return http_host_stub().split(':')[0]
 
 
 @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_only_stub(),
         'SERVER_PORT': http_host_stub.split(':')[1],
         'HTTP_HOST': http_host_stub,
         'HTTP_USER_AGENT': 'rc-test-agent',
         'REQUEST_METHOD': 'GET'
     }
 
 
 @pytest.fixture(scope='session')
 def baseapp(ini_config, vcsserver, http_environ_session):
     from rhodecode.lib.pyramid_utils import get_app_config
     from rhodecode.config.middleware import make_pyramid_app
 
     print("Using the RhodeCode configuration:{}".format(ini_config))
     pyramid.paster.setup_logging(ini_config)
 
     settings = get_app_config(ini_config)
     app = make_pyramid_app({'__file__': ini_config}, **settings)
 
     return app
 
 
 @pytest.fixture(scope='function')
 def app(request, config_stub, baseapp, http_environ):
     app = CustomTestApp(
         baseapp,
         extra_environ=http_environ)
     if request.cls:
         request.cls.app = app
     return app
 
 
 @pytest.fixture(scope='session')
 def app_settings(baseapp, ini_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`.
     """
     return baseapp.config.get_settings()
 
 
 @pytest.fixture(scope='session')
 def db_connection(ini_settings):
     # Initialize the database connection.
     config_utils.initialize_database(ini_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, baseapp):
     index_location = baseapp.config.get_settings()['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' % str(time.time()).replace('.', '')
     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' % str(time.time()).replace('.', '')
     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, config=None):
         key = (dump_name, backend_alias)
         if key not in self._repos:
             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, 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, 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, baseapp, 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, baseapp, test_repo):
     return backend(request, 'git', baseapp, test_repo)
 
 
 @pytest.fixture
 def backend_hg(request, baseapp, test_repo):
     return backend(request, 'hg', baseapp, test_repo)
 
 
 @pytest.fixture
 def backend_svn(request, baseapp, test_repo):
     return backend(request, 'svn', baseapp, 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):
+            name_suffix=u'', bare=False, **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.
-
+        :param name_suffix: adds special suffix to generated repo name
+        :param bare: set a repo as bare (no checkout)
         """
         self.repo_name = self._next_repo_name() + name_suffix
         repo = self._fixture.create_repo(
-            self.repo_name, repo_type=self.alias, **kwargs)
+            self.repo_name, repo_type=self.alias, bare=bare, **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)]
+            for x in range(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, baseapp, 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, baseapp, test_repo):
     return vcsbackend(request, 'git', tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_hg(request, tests_tmp_path, baseapp, test_repo):
     return vcsbackend(request, 'hg', tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_svn(request, tests_tmp_path, baseapp, test_repo):
     return vcsbackend(request, 'svn', tests_tmp_path, baseapp, 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):
+    def create_repo(self, commits=None, number_of_commits=0, _clone_repo=None,
+                    bare=False):
         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)
+        repo = repo_class(self._repo_path, create=True, src_url=src_url, bare=bare)
         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, config_stub):
     """
     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(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):
         return [
             (TEST_USER_REGULAR_LOGIN, ['default1'], False, []),
             (TEST_USER_REGULAR2_LOGIN, ['default2'], False, []),
         ]
 
     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, pull_request.author)
             Session().commit()
 
         if self.notification_patcher:
             self.notification_patcher.stop()
 
         if self.mergeable_patcher:
             self.mergeable_patcher.stop()
 
 
 @pytest.fixture
 def user_admin(baseapp):
     """
     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(baseapp):
     """
     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, db_connection):
     """
     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'):
+                    auto_cleanup=True, repo_type='hg', bare=False):
         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)
+            repo_name, cur_user=owner, repo_group=parent, repo_type=repo_type, bare=bare)
         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_additional_user_email(self, user, email):
         uem = self.fixture.create_additional_user_email(user=user, email=email)
         return uem
 
     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 baseapp 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.
         baseapp = request.getfuncargvalue("baseapp")
     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 = baseapp.config.get_settings()['vcs.server']
     protocol = baseapp.config.get_settings()['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, db_connection):
     """
     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, db_connection):
     """
     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(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 context_stub():
     """
     Stub context object.
     """
     context = pyramid.testing.DummyResource()
     return context
 
 
 @pytest.fixture
 def request_stub():
     """
     Stub request object.
     """
     from rhodecode.lib.base import bootstrap_request
     request = bootstrap_request(scheme='https')
     return request
 
 
 @pytest.fixture
 def config_stub(request, request_stub):
     """
     Set up pyramid.testing and return the Configurator.
     """
     from rhodecode.lib.base import bootstrap_config
     config = bootstrap_config(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'
 
         @classmethod
         def icon(cls):
             return '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
 
 
 @pytest.fixture
 def disable_anonymous_user(request, baseapp):
     set_anonymous_access(False)
 
     @request.addfinalizer
     def cleanup():
         set_anonymous_access(True)
 
 
 @pytest.fixture(scope='module')
 def rc_fixture(request):
     return Fixture()
 
 
 @pytest.fixture
 def repo_groups(request):
     fixture = Fixture()
 
     session = Session()
     zombie_group = fixture.create_repo_group('zombie')
     parent_group = fixture.create_repo_group('parent')
     child_group = fixture.create_repo_group('parent/child')
     groups_in_db = session.query(RepoGroup).all()
     assert len(groups_in_db) == 3
     assert child_group.group_parent_id == parent_group.group_id
 
     @request.addfinalizer
     def cleanup():
         fixture.destroy_repo_group(zombie_group)
         fixture.destroy_repo_group(child_group)
         fixture.destroy_repo_group(parent_group)
 
     return zombie_group, parent_group, child_group

rhodecode/tests/vcs/test_git.py

@@ -1,1289 +1,1288 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import datetime
 import mock
 import os
 import sys
 import shutil
 
 import pytest
 
 from rhodecode.lib.utils import make_db_config
 from rhodecode.lib.vcs.backends.base import Reference
 from rhodecode.lib.vcs.backends.git import (
     GitRepository, GitCommit, discover_git_version)
 from rhodecode.lib.vcs.exceptions import (
     RepositoryError, VCSError, NodeDoesNotExistError)
 from rhodecode.lib.vcs.nodes import (
     NodeKind, FileNode, DirNode, NodeState, SubModuleNode)
 from rhodecode.tests import TEST_GIT_REPO, TEST_GIT_REPO_CLONE, get_new_dir
 from rhodecode.tests.vcs.conftest import BackendTestMixin
 
 
 pytestmark = pytest.mark.backends("git")
 
 
 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, baseapp):
         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_git'
         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)
+            src_url=TEST_GIT_REPO, create=True, do_workspace_checkout=True)
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
         # Checking hashes of commits should be enough
         for commit in repo.get_commits():
             raw_id = commit.raw_id
             assert raw_id == repo_clone.get_commit(raw_id).raw_id
 
     def test_repo_clone_without_create(self):
         with pytest.raises(RepositoryError):
             GitRepository(
                 TEST_GIT_REPO_CLONE + '_wo_create', src_url=TEST_GIT_REPO)
 
     def test_repo_clone_with_update(self):
         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)
+            create=True, src_url=TEST_GIT_REPO, do_workspace_checkout=True)
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
 
         # check if current workdir was updated
         fpath = os.path.join(clone_path, 'MANIFEST.in')
         assert os.path.isfile(fpath)
 
     def test_repo_clone_without_update(self):
         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)
+            create=True, src_url=TEST_GIT_REPO, do_workspace_checkout=False)
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
         # check if current workdir was *NOT* updated
         fpath = os.path.join(clone_path, 'MANIFEST.in')
         # Make sure it's not bare repo
         assert not repo_clone.bare
         assert not os.path.isfile(fpath)
 
     def test_repo_clone_into_bare_repo(self):
         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 = vcsbackend_git.create_repo(bare=True)
         target_repo.fetch(source_repo.path)
         # Note: Get a fresh instance, avoids caching trouble
         target_repo = vcsbackend_git.backend(target_repo.path)
         assert len(source_repo.commit_ids) == len(target_repo.commit_ids)
 
     def test_commit_ids(self):
         # there are 112 commits (by now)
         # so we can assume they would be available from now on
-        subset = set([
-            'c1214f7e79e02fc37156ff215cd71275450cffc3',
+        subset = {'c1214f7e79e02fc37156ff215cd71275450cffc3',
             '38b5fe81f109cb111f549bfe9bb6b267e10bc557',
             'fa6600f6848800641328adbf7811fd2372c02ab2',
             '102607b09cdd60e2793929c4f90478be29f85a17',
             '49d3fd156b6f7db46313fac355dca1a0b94a0017',
             '2d1028c054665b962fa3d307adfc923ddd528038',
             'd7e0d30fbcae12c90680eb095a4f5f02505ce501',
             'ff7ca51e58c505fec0dd2491de52c622bb7a806b',
             'dd80b0f6cf5052f17cc738c2951c4f2070200d7f',
             '8430a588b43b5d6da365400117c89400326e7992',
             'd955cd312c17b02143c04fa1099a352b04368118',
             'f67b87e5c629c2ee0ba58f85197e423ff28d735b',
             'add63e382e4aabc9e1afdc4bdc24506c269b7618',
             'f298fe1189f1b69779a4423f40b48edf92a703fc',
             'bd9b619eb41994cac43d67cf4ccc8399c1125808',
             '6e125e7c890379446e98980d8ed60fba87d0f6d1',
             'd4a54db9f745dfeba6933bf5b1e79e15d0af20bd',
             '0b05e4ed56c802098dfc813cbe779b2f49e92500',
             '191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e',
             '45223f8f114c64bf4d6f853e3c35a369a6305520',
             'ca1eb7957a54bce53b12d1a51b13452f95bc7c7e',
             'f5ea29fc42ef67a2a5a7aecff10e1566699acd68',
             '27d48942240f5b91dfda77accd2caac94708cc7d',
             '622f0eb0bafd619d2560c26f80f09e3b0b0d78af',
-            'e686b958768ee96af8029fe19c6050b1a8dd3b2b'])
+                  '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',))
+        assert set(repo_clone.branches) == {'master'}
         repo_clone._checkout(new_branch, create=True)
 
         # Branches is a lazy property so we need to recrete the Repo object.
         repo_clone = GitRepository(repo_clone.path)
-        assert set(repo_clone.branches) == set(('master', new_branch))
+        assert set(repo_clone.branches) == {'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(
             2, 'pr2', Reference('branch', 'master', 'unused'),
             Reference('branch', 'master', 'unused'))
 
         assert os.path.isdir(workspace)
         workspace_repo = GitRepository(workspace)
         assert workspace_repo.branches == self.repo.branches
 
         # Calling it a second time should also succeed
         workspace = self.repo._maybe_prepare_merge_workspace(
             2, 'pr2', Reference('branch', 'master', 'unused'),
             Reference('branch', 'master', 'unused'))
         assert os.path.isdir(workspace)
 
     def test_maybe_prepare_merge_workspace_different_refs(self):
         workspace = self.repo._maybe_prepare_merge_workspace(
             2, 'pr2', Reference('branch', 'master', 'unused'),
             Reference('branch', 'develop', 'unused'))
 
         assert os.path.isdir(workspace)
         workspace_repo = GitRepository(workspace)
         assert workspace_repo.branches == self.repo.branches
 
         # Calling it a second time should also succeed
         workspace = self.repo._maybe_prepare_merge_workspace(
             2, 'pr2', Reference('branch', 'master', 'unused'),
             Reference('branch', 'develop', 'unused'))
         assert os.path.isdir(workspace)
 
     def test_cleanup_merge_workspace(self):
         workspace = self.repo._maybe_prepare_merge_workspace(
             2, 'pr3', Reference('branch', 'master', 'unused'),
             Reference('branch', 'master', 'unused'))
         self.repo.cleanup_merge_workspace(2, 'pr3')
 
         assert not os.path.exists(workspace)
 
     def test_cleanup_merge_workspace_invalid_workspace_id(self):
         # No assert: because in case of an inexistent workspace this function
         # should still succeed.
         self.repo.cleanup_merge_workspace(1, 'pr4')
 
     def test_set_refs(self):
         test_ref = 'refs/test-refs/abcde'
         test_commit_id = 'ecb86e1f424f2608262b130db174a7dfd25a6623'
 
         self.repo.set_refs(test_ref, test_commit_id)
         stdout, _ = self.repo.run_git_command(['show-ref'])
         assert test_ref in stdout
         assert test_commit_id in stdout
 
     def test_remove_ref(self):
         test_ref = 'refs/test-refs/abcde'
         test_commit_id = 'ecb86e1f424f2608262b130db174a7dfd25a6623'
         self.repo.set_refs(test_ref, test_commit_id)
         stdout, _ = self.repo.run_git_command(['show-ref'])
         assert test_ref in stdout
         assert test_commit_id in stdout
 
         self.repo.remove_ref(test_ref)
         stdout, _ = self.repo.run_git_command(['show-ref'])
         assert test_ref not in stdout
         assert test_commit_id not in stdout
 
 
 class TestGitCommit(object):
 
     @pytest.fixture(autouse=True)
     def prepare(self):
         self.repo = GitRepository(TEST_GIT_REPO)
 
     def test_default_commit(self):
         tip = self.repo.get_commit()
         assert tip == self.repo.get_commit(None)
         assert tip == self.repo.get_commit('tip')
 
     def test_root_node(self):
         tip = self.repo.get_commit()
         assert tip.root is tip.get_node('')
 
     def test_lazy_fetch(self):
         """
         Test if commit's nodes expands and are cached as we walk through
         the commit. This test is somewhat hard to write as order of tests
         is a key here. Written by running command after command in a shell.
         """
         commit_id = '2a13f185e4525f9d4b59882791a2d397b90d5ddc'
         assert commit_id in self.repo.commit_ids
         commit = self.repo.get_commit(commit_id)
         assert len(commit.nodes) == 0
         root = commit.root
         assert len(commit.nodes) == 1
         assert len(root.nodes) == 8
         # accessing root.nodes updates commit.nodes
         assert len(commit.nodes) == 9
 
         docs = root.get_node('docs')
         # we haven't yet accessed anything new as docs dir was already cached
         assert len(commit.nodes) == 9
         assert len(docs.nodes) == 8
         # accessing docs.nodes updates commit.nodes
         assert len(commit.nodes) == 17
 
         assert docs is commit.get_node('docs')
         assert docs is root.nodes[0]
         assert docs is root.dirs[0]
         assert docs is commit.get_node('docs')
 
     def test_nodes_with_commit(self):
         commit_id = '2a13f185e4525f9d4b59882791a2d397b90d5ddc'
         commit = self.repo.get_commit(commit_id)
         root = commit.root
         docs = root.get_node('docs')
         assert docs is commit.get_node('docs')
         api = docs.get_node('api')
         assert api is commit.get_node('docs/api')
         index = api.get_node('index.rst')
         assert index is commit.get_node('docs/api/index.rst')
         assert index is commit.get_node('docs')\
             .get_node('api')\
             .get_node('index.rst')
 
     def test_branch_and_tags(self):
         """
         rev0 = self.repo.commit_ids[0]
         commit0 = self.repo.get_commit(rev0)
         assert commit0.branch == 'master'
         assert commit0.tags == []
 
         rev10 = self.repo.commit_ids[10]
         commit10 = self.repo.get_commit(rev10)
         assert commit10.branch == 'master'
         assert commit10.tags == []
 
         rev44 = self.repo.commit_ids[44]
         commit44 = self.repo.get_commit(rev44)
         assert commit44.branch == 'web-branch'
 
         tip = self.repo.get_commit('tip')
         assert 'tip' in tip.tags
         """
         # Those tests would fail - branches are now going
         # to be changed at main API in order to support git backend
         pass
 
     def test_file_size(self):
         to_check = (
             ('c1214f7e79e02fc37156ff215cd71275450cffc3',
                 'vcs/backends/BaseRepository.py', 502),
             ('d7e0d30fbcae12c90680eb095a4f5f02505ce501',
                 'vcs/backends/hg.py', 854),
             ('6e125e7c890379446e98980d8ed60fba87d0f6d1',
                 'setup.py', 1068),
 
             ('d955cd312c17b02143c04fa1099a352b04368118',
                 'vcs/backends/base.py', 2921),
             ('ca1eb7957a54bce53b12d1a51b13452f95bc7c7e',
                 'vcs/backends/base.py', 3936),
             ('f50f42baeed5af6518ef4b0cb2f1423f3851a941',
                 'vcs/backends/base.py', 6189),
         )
         for commit_id, path, size in to_check:
             node = self.repo.get_commit(commit_id).get_node(path)
             assert node.is_file()
             assert node.size == size
 
     def test_file_history_from_commits(self):
         node = self.repo[10].get_node('setup.py')
         commit_ids = [commit.raw_id for commit in node.history]
         assert ['ff7ca51e58c505fec0dd2491de52c622bb7a806b'] == commit_ids
 
         node = self.repo[20].get_node('setup.py')
         node_ids = [commit.raw_id for commit in node.history]
         assert ['191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e',
                 'ff7ca51e58c505fec0dd2491de52c622bb7a806b'] == node_ids
 
         # special case we check history from commit that has this particular
         # file changed this means we check if it's included as well
         node = self.repo.get_commit('191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e') \
             .get_node('setup.py')
         node_ids = [commit.raw_id for commit in node.history]
         assert ['191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e',
                 'ff7ca51e58c505fec0dd2491de52c622bb7a806b'] == node_ids
 
     def test_file_history(self):
         # we can only check if those commits are present in the history
         # as we cannot update this test every time file is changed
         files = {
             'setup.py': [
                 '54386793436c938cff89326944d4c2702340037d',
                 '51d254f0ecf5df2ce50c0b115741f4cf13985dab',
                 '998ed409c795fec2012b1c0ca054d99888b22090',
                 '5e0eb4c47f56564395f76333f319d26c79e2fb09',
                 '0115510b70c7229dbc5dc49036b32e7d91d23acd',
                 '7cb3fd1b6d8c20ba89e2264f1c8baebc8a52d36e',
                 '2a13f185e4525f9d4b59882791a2d397b90d5ddc',
                 '191caa5b2c81ed17c0794bf7bb9958f4dcb0b87e',
                 'ff7ca51e58c505fec0dd2491de52c622bb7a806b',
             ],
             'vcs/nodes.py': [
                 '33fa3223355104431402a888fa77a4e9956feb3e',
                 'fa014c12c26d10ba682fadb78f2a11c24c8118e1',
                 'e686b958768ee96af8029fe19c6050b1a8dd3b2b',
                 'ab5721ca0a081f26bf43d9051e615af2cc99952f',
                 'c877b68d18e792a66b7f4c529ea02c8f80801542',
                 '4313566d2e417cb382948f8d9d7c765330356054',
                 '6c2303a793671e807d1cfc70134c9ca0767d98c2',
                 '54386793436c938cff89326944d4c2702340037d',
                 '54000345d2e78b03a99d561399e8e548de3f3203',
                 '1c6b3677b37ea064cb4b51714d8f7498f93f4b2b',
                 '2d03ca750a44440fb5ea8b751176d1f36f8e8f46',
                 '2a08b128c206db48c2f0b8f70df060e6db0ae4f8',
                 '30c26513ff1eb8e5ce0e1c6b477ee5dc50e2f34b',
                 'ac71e9503c2ca95542839af0ce7b64011b72ea7c',
                 '12669288fd13adba2a9b7dd5b870cc23ffab92d2',
                 '5a0c84f3e6fe3473e4c8427199d5a6fc71a9b382',
                 '12f2f5e2b38e6ff3fbdb5d722efed9aa72ecb0d5',
                 '5eab1222a7cd4bfcbabc218ca6d04276d4e27378',
                 'f50f42baeed5af6518ef4b0cb2f1423f3851a941',
                 'd7e390a45f6aa96f04f5e7f583ad4f867431aa25',
                 'f15c21f97864b4f071cddfbf2750ec2e23859414',
                 'e906ef056cf539a4e4e5fc8003eaf7cf14dd8ade',
                 'ea2b108b48aa8f8c9c4a941f66c1a03315ca1c3b',
                 '84dec09632a4458f79f50ddbbd155506c460b4f9',
                 '0115510b70c7229dbc5dc49036b32e7d91d23acd',
                 '2a13f185e4525f9d4b59882791a2d397b90d5ddc',
                 '3bf1c5868e570e39569d094f922d33ced2fa3b2b',
                 'b8d04012574729d2c29886e53b1a43ef16dd00a1',
                 '6970b057cffe4aab0a792aa634c89f4bebf01441',
                 'dd80b0f6cf5052f17cc738c2951c4f2070200d7f',
                 'ff7ca51e58c505fec0dd2491de52c622bb7a806b',
             ],
             'vcs/backends/git.py': [
                 '4cf116ad5a457530381135e2f4c453e68a1b0105',
                 '9a751d84d8e9408e736329767387f41b36935153',
                 'cb681fb539c3faaedbcdf5ca71ca413425c18f01',
                 '428f81bb652bcba8d631bce926e8834ff49bdcc6',
                 '180ab15aebf26f98f714d8c68715e0f05fa6e1c7',
                 '2b8e07312a2e89e92b90426ab97f349f4bce2a3a',
                 '50e08c506174d8645a4bb517dd122ac946a0f3bf',
                 '54000345d2e78b03a99d561399e8e548de3f3203',
             ],
         }
         for path, commit_ids in files.items():
             node = self.repo.get_commit(commit_ids[0]).get_node(path)
             node_ids = [commit.raw_id for commit in node.history]
             assert set(commit_ids).issubset(set(node_ids)), (
                 "We assumed that %s is subset of commit_ids for which file %s "
                 "has been changed, and history of that node returned: %s"
                 % (commit_ids, path, node_ids))
 
     def test_file_annotate(self):
         files = {
             'vcs/backends/__init__.py': {
                 'c1214f7e79e02fc37156ff215cd71275450cffc3': {
                     'lines_no': 1,
                     'commits': [
                         'c1214f7e79e02fc37156ff215cd71275450cffc3',
                     ],
                 },
                 '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647': {
                     'lines_no': 21,
                     'commits': [
                         '49d3fd156b6f7db46313fac355dca1a0b94a0017',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                     ],
                 },
                 'e29b67bd158580fc90fc5e9111240b90e6e86064': {
                     'lines_no': 32,
                     'commits': [
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '5eab1222a7cd4bfcbabc218ca6d04276d4e27378',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '54000345d2e78b03a99d561399e8e548de3f3203',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '78c3f0c23b7ee935ec276acb8b8212444c33c396',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '2a13f185e4525f9d4b59882791a2d397b90d5ddc',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '78c3f0c23b7ee935ec276acb8b8212444c33c396',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '992f38217b979d0b0987d0bae3cc26dac85d9b19',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                         '16fba1ae9334d79b66d7afed2c2dfbfa2ae53647',
                     ],
                 },
             },
         }
 
         for fname, commit_dict in files.items():
             for commit_id, __ in commit_dict.items():
                 commit = self.repo.get_commit(commit_id)
 
                 l1_1 = [x[1] for x in commit.get_file_annotate(fname)]
                 l1_2 = [x[2]().raw_id for x in commit.get_file_annotate(fname)]
                 assert l1_1 == l1_2
                 l1 = l1_1
                 l2 = files[fname][commit_id]['commits']
                 assert l1 == l2, (
                     "The lists of commit_ids for %s@commit_id %s"
                     "from annotation list should match each other, "
                     "got \n%s \nvs \n%s " % (fname, commit_id, l1, l2))
 
     def test_files_state(self):
         """
         Tests state of FileNodes.
         """
         node = self.repo\
             .get_commit('e6ea6d16e2f26250124a1f4b4fe37a912f9d86a0')\
             .get_node('vcs/utils/diffs.py')
         assert node.state, NodeState.ADDED
         assert node.added
         assert not node.changed
         assert not node.not_changed
         assert not node.removed
 
         node = self.repo\
             .get_commit('33fa3223355104431402a888fa77a4e9956feb3e')\
             .get_node('.hgignore')
         assert node.state, NodeState.CHANGED
         assert not node.added
         assert node.changed
         assert not node.not_changed
         assert not node.removed
 
         node = self.repo\
             .get_commit('e29b67bd158580fc90fc5e9111240b90e6e86064')\
             .get_node('setup.py')
         assert node.state, NodeState.NOT_CHANGED
         assert not node.added
         assert not node.changed
         assert node.not_changed
         assert not node.removed
 
         # If node has REMOVED state then trying to fetch it would raise
         # CommitError exception
         commit = self.repo.get_commit(
             'fa6600f6848800641328adbf7811fd2372c02ab2')
         path = 'vcs/backends/BaseRepository.py'
         with pytest.raises(NodeDoesNotExistError):
             commit.get_node(path)
         # but it would be one of ``removed`` (commit's attribute)
         assert path in [rf.path for rf in commit.removed]
 
         commit = self.repo.get_commit(
             '54386793436c938cff89326944d4c2702340037d')
         changed = [
             'setup.py', 'tests/test_nodes.py', 'vcs/backends/hg.py',
             'vcs/nodes.py']
         assert set(changed) == set([f.path for f in commit.changed])
 
     def test_unicode_branch_refs(self):
         unicode_branches = {
             'refs/heads/unicode': '6c0ce52b229aa978889e91b38777f800e85f330b',
             u'refs/heads/uniçö∂e': 'ürl',
         }
         with mock.patch(
             ("rhodecode.lib.vcs.backends.git.repository"
                 ".GitRepository._refs"),
                 unicode_branches):
             branches = self.repo.branches
 
         assert 'unicode' in branches
         assert u'uniçö∂e' in branches
 
     def test_unicode_tag_refs(self):
         unicode_tags = {
             'refs/tags/unicode': '6c0ce52b229aa978889e91b38777f800e85f330b',
             u'refs/tags/uniçö∂e': '6c0ce52b229aa978889e91b38777f800e85f330b',
         }
         with mock.patch(
             ("rhodecode.lib.vcs.backends.git.repository"
                 ".GitRepository._refs"),
                 unicode_tags):
             tags = self.repo.tags
 
         assert 'unicode' in tags
         assert u'uniçö∂e' in tags
 
     def test_commit_message_is_unicode(self):
         for commit in self.repo:
             assert type(commit.message) == unicode
 
     def test_commit_author_is_unicode(self):
         for commit in self.repo:
             assert type(commit.author) == unicode
 
     def test_repo_files_content_is_unicode(self):
         commit = self.repo.get_commit()
         for node in commit.get_node('/'):
             if node.is_file():
                 assert type(node.content) == unicode
 
     def test_wrong_path(self):
         # There is 'setup.py' in the root dir but not there:
         path = 'foo/bar/setup.py'
         tip = self.repo.get_commit()
         with pytest.raises(VCSError):
             tip.get_node(path)
 
     @pytest.mark.parametrize("author_email, commit_id", [
         ('[e-mail]', 'c1214f7e79e02fc37156ff215cd71275450cffc3'),
         ('[e-mail]',
          'ff7ca51e58c505fec0dd2491de52c622bb7a806b'),
         ('none@none', '8430a588b43b5d6da365400117c89400326e7992'),
     ])
     def test_author_email(self, author_email, commit_id):
         commit = self.repo.get_commit(commit_id)
         assert author_email == commit.author_email
 
     @pytest.mark.parametrize("author, commit_id", [
         ('Marcin Kuzminski', 'c1214f7e79e02fc37156ff215cd71275450cffc3'),
         ('Lukasz Balcerzak', 'ff7ca51e58c505fec0dd2491de52c622bb7a806b'),
         ('marcink', '8430a588b43b5d6da365400117c89400326e7992'),
     ])
     def test_author_username(self, author, commit_id):
         commit = self.repo.get_commit(commit_id)
         assert author == commit.author_name
 
 
 class TestLargeFileRepo(object):
 
     def test_large_file(self, backend_git):
         conf = make_db_config()
         repo = backend_git.create_test_repo('largefiles', conf)
 
         tip = repo.scm_instance().get_commit()
 
         # extract stored LF node into the origin cache
         lfs_store = os.path.join(repo.repo_path, repo.repo_name, 'lfs_store')
 
         oid = '7b331c02e313c7599d5a90212e17e6d3cb729bd2e1c9b873c302a63c95a2f9bf'
         oid_path = os.path.join(lfs_store, oid)
         oid_destination = os.path.join(
             conf.get('vcs_git_lfs', 'store_location'), oid)
         shutil.copy(oid_path, oid_destination)
 
         node = tip.get_node('1MB.zip')
 
         lf_node = node.get_largefile_node()
 
         assert lf_node.is_largefile() is True
         assert lf_node.size == 1024000
         assert lf_node.name == '1MB.zip'
 
 
 @pytest.mark.usefixtures("vcs_repository_support")
 class TestGitSpecificWithRepo(BackendTestMixin):
 
     @classmethod
     def _get_commits(cls):
         return [
             {
                 'message': 'Initial',
                 'author': 'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('foobar/static/js/admin/base.js', content='base'),
                     FileNode(
                         'foobar/static/admin', content='admin',
                         mode=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'])
 
 
 @pytest.mark.usefixtures("vcs_repository_support")
 class TestGitRegression(BackendTestMixin):
 
     @classmethod
     def _get_commits(cls):
         return [
             {
                 'message': 'Initial',
                 'author': 'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('bot/__init__.py', content='base'),
                     FileNode('bot/templates/404.html', content='base'),
                     FileNode('bot/templates/500.html', content='base'),
                 ],
             },
             {
                 'message': 'Second',
                 'author': 'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 22),
                 'added': [
                     FileNode('bot/build/migrations/1.py', content='foo2'),
                     FileNode('bot/build/migrations/2.py', content='foo2'),
                     FileNode(
                         'bot/build/static/templates/f.html', content='foo2'),
                     FileNode(
                         'bot/build/static/templates/f1.html', content='foo2'),
                     FileNode('bot/build/templates/err.html', content='foo2'),
                     FileNode('bot/build/templates/err2.html', content='foo2'),
                 ],
             },
         ]
 
     @pytest.mark.parametrize("path, expected_paths", [
         ('bot', [
             'bot/build',
             'bot/templates',
             'bot/__init__.py']),
         ('bot/build', [
             'bot/build/migrations',
             'bot/build/static',
             'bot/build/templates']),
         ('bot/build/static', [
             'bot/build/static/templates']),
         ('bot/build/static/templates', [
             'bot/build/static/templates/f.html',
             'bot/build/static/templates/f1.html']),
         ('bot/build/templates', [
             'bot/build/templates/err.html',
             'bot/build/templates/err2.html']),
         ('bot/templates/', [
             'bot/templates/404.html',
             'bot/templates/500.html']),
     ])
     def test_similar_paths(self, path, expected_paths):
         commit = self.repo.get_commit()
         paths = [n.path for n in commit.get_nodes(path)]
         assert paths == expected_paths
 
 
-class TestDiscoverGitVersion:
+class TestDiscoverGitVersion(object):
 
     def test_returns_git_version(self, baseapp):
         version = discover_git_version()
         assert version
 
     def test_returns_empty_string_without_vcsserver(self):
         mock_connection = mock.Mock()
         mock_connection.discover_git_version = mock.Mock(
             side_effect=Exception)
         with mock.patch('rhodecode.lib.vcs.connection.Git', mock_connection):
             version = discover_git_version()
         assert version == ''
 
 
 class TestGetSubmoduleUrl(object):
     def test_submodules_file_found(self):
         commit = GitCommit(repository=mock.Mock(), raw_id='abcdef12', idx=1)
         node = mock.Mock()
         with mock.patch.object(
                 commit, 'get_node', return_value=node) as get_node_mock:
             node.content = (
                 '[submodule "subrepo1"]\n'
                 '\tpath = subrepo1\n'
                 '\turl = https://code.rhodecode.com/dulwich\n'
             )
             result = commit._get_submodule_url('subrepo1')
         get_node_mock.assert_called_once_with('.gitmodules')
         assert result == 'https://code.rhodecode.com/dulwich'
 
     def test_complex_submodule_path(self):
         commit = GitCommit(repository=mock.Mock(), raw_id='abcdef12', idx=1)
         node = mock.Mock()
         with mock.patch.object(
                 commit, 'get_node', return_value=node) as get_node_mock:
             node.content = (
                 '[submodule "complex/subrepo/path"]\n'
                 '\tpath = complex/subrepo/path\n'
                 '\turl = https://code.rhodecode.com/dulwich\n'
             )
             result = commit._get_submodule_url('complex/subrepo/path')
         get_node_mock.assert_called_once_with('.gitmodules')
         assert result == 'https://code.rhodecode.com/dulwich'
 
     def test_submodules_file_not_found(self):
         commit = GitCommit(repository=mock.Mock(), raw_id='abcdef12', idx=1)
         with mock.patch.object(
                 commit, 'get_node', side_effect=NodeDoesNotExistError):
             result = commit._get_submodule_url('complex/subrepo/path')
         assert result is None
 
     def test_path_not_found(self):
         commit = GitCommit(repository=mock.Mock(), raw_id='abcdef12', idx=1)
         node = mock.Mock()
         with mock.patch.object(
                 commit, 'get_node', return_value=node) as get_node_mock:
             node.content = (
                 '[submodule "subrepo1"]\n'
                 '\tpath = subrepo1\n'
                 '\turl = https://code.rhodecode.com/dulwich\n'
             )
             result = commit._get_submodule_url('subrepo2')
         get_node_mock.assert_called_once_with('.gitmodules')
         assert result is None
 
     def test_returns_cached_values(self):
         commit = GitCommit(repository=mock.Mock(), raw_id='abcdef12', idx=1)
         node = mock.Mock()
         with mock.patch.object(
                 commit, 'get_node', return_value=node) as get_node_mock:
             node.content = (
                 '[submodule "subrepo1"]\n'
                 '\tpath = subrepo1\n'
                 '\turl = https://code.rhodecode.com/dulwich\n'
             )
             for _ in range(3):
                 commit._get_submodule_url('subrepo1')
         get_node_mock.assert_called_once_with('.gitmodules')
 
     def test_get_node_returns_a_link(self):
         repository = mock.Mock()
         repository.alias = 'git'
         commit = GitCommit(repository=repository, raw_id='abcdef12', idx=1)
         submodule_url = 'https://code.rhodecode.com/dulwich'
         get_id_patch = mock.patch.object(
             commit, '_get_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,1186 +1,1186 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 
 import mock
 import pytest
 
 from rhodecode.lib.utils import make_db_config
 from rhodecode.lib.vcs import backends
 from rhodecode.lib.vcs.backends.base import (
     Reference, MergeResponse, MergeFailureReason)
 from rhodecode.lib.vcs.backends.hg import MercurialRepository, MercurialCommit
 from rhodecode.lib.vcs.exceptions import (
     RepositoryError, VCSError, NodeDoesNotExistError, CommitDoesNotExistError)
 from rhodecode.lib.vcs.nodes import FileNode, NodeKind, NodeState
 from rhodecode.tests import TEST_HG_REPO, TEST_HG_REPO_CLONE, repo_id_generator
 
 
 pytestmark = pytest.mark.backends("hg")
 
 
 def repo_path_generator():
     """
     Return a different path to be used for cloning repos.
     """
     i = 0
     while True:
         i += 1
         yield '%s-%d' % (TEST_HG_REPO_CLONE, i)
 
 REPO_PATH_GENERATOR = repo_path_generator()
 
 
 @pytest.fixture(scope='class', autouse=True)
 def repo(request, baseapp):
     repo = MercurialRepository(TEST_HG_REPO)
     if request.cls:
         request.cls.repo = repo
     return repo
 
 
 class TestMercurialRepository:
 
     # pylint: disable=protected-access
 
     def get_clone_repo(self):
         """
         Return a clone of the base repo.
         """
         clone_path = next(REPO_PATH_GENERATOR)
         repo_clone = MercurialRepository(
             clone_path, create=True, src_url=self.repo.path)
 
         return repo_clone
 
     def get_empty_repo(self):
         """
         Return an empty repo.
         """
         return MercurialRepository(next(REPO_PATH_GENERATOR), create=True)
 
     def test_wrong_repo_path(self):
         wrong_repo_path = '/tmp/errorrepo_hg'
         with pytest.raises(RepositoryError):
             MercurialRepository(wrong_repo_path)
 
     def test_unicode_path_repo(self):
         with pytest.raises(VCSError):
             MercurialRepository(u'iShouldFail')
 
     def test_unicode_commit_id(self):
         with pytest.raises(CommitDoesNotExistError):
             self.repo.get_commit(u'unicode-commit-id')
         with pytest.raises(CommitDoesNotExistError):
             self.repo.get_commit(u'unícøde-spéçial-chäråcter-commit-id')
 
     def test_unicode_bookmark(self):
         self.repo.bookmark(u'unicode-bookmark')
         self.repo.bookmark(u'unícøde-spéçial-chäråcter-bookmark')
 
     def test_unicode_branch(self):
         with pytest.raises(KeyError):
             self.repo.branches[u'unicode-branch']
         with pytest.raises(KeyError):
             self.repo.branches[u'unícøde-spéçial-chäråcter-branch']
 
     def test_repo_clone(self):
         if os.path.exists(TEST_HG_REPO_CLONE):
             self.fail(
                 'Cannot test mercurial clone repo as location %s already '
                 'exists. You should manually remove it first.'
                 % TEST_HG_REPO_CLONE)
 
         repo = MercurialRepository(TEST_HG_REPO)
         repo_clone = MercurialRepository(TEST_HG_REPO_CLONE,
                                          src_url=TEST_HG_REPO)
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
         # Checking hashes of commits should be enough
         for commit in repo.get_commits():
             raw_id = commit.raw_id
             assert raw_id == repo_clone.get_commit(raw_id).raw_id
 
     def test_repo_clone_with_update(self):
         repo = MercurialRepository(TEST_HG_REPO)
         repo_clone = MercurialRepository(
             TEST_HG_REPO_CLONE + '_w_update',
-            src_url=TEST_HG_REPO, update_after_clone=True)
+            src_url=TEST_HG_REPO, do_workspace_checkout=True)
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
 
         # check if current workdir was updated
         assert os.path.isfile(
             os.path.join(TEST_HG_REPO_CLONE + '_w_update', 'MANIFEST.in'))
 
     def test_repo_clone_without_update(self):
         repo = MercurialRepository(TEST_HG_REPO)
         repo_clone = MercurialRepository(
             TEST_HG_REPO_CLONE + '_wo_update',
-            src_url=TEST_HG_REPO, update_after_clone=False)
+            src_url=TEST_HG_REPO, do_workspace_checkout=False)
         assert len(repo.commit_ids) == len(repo_clone.commit_ids)
         assert not os.path.isfile(
             os.path.join(TEST_HG_REPO_CLONE + '_wo_update', 'MANIFEST.in'))
 
     def test_commit_ids(self):
         # there are 21 commits at bitbucket now
         # so we can assume they would be available from now on
         subset = set([
             'b986218ba1c9b0d6a259fac9b050b1724ed8e545',
             '3d8f361e72ab303da48d799ff1ac40d5ac37c67e',
             '6cba7170863a2411822803fa77a0a264f1310b35',
             '56349e29c2af3ac913b28bde9a2c6154436e615b',
             '2dda4e345facb0ccff1a191052dd1606dba6781d',
             '6fff84722075f1607a30f436523403845f84cd9e',
             '7d4bc8ec6be56c0f10425afb40b6fc315a4c25e7',
             '3803844fdbd3b711175fc3da9bdacfcd6d29a6fb',
             'dc5d2c0661b61928834a785d3e64a3f80d3aad9c',
             'be90031137367893f1c406e0a8683010fd115b79',
             'db8e58be770518cbb2b1cdfa69146e47cd481481',
             '84478366594b424af694a6c784cb991a16b87c21',
             '17f8e105dddb9f339600389c6dc7175d395a535c',
             '20a662e756499bde3095ffc9bc0643d1def2d0eb',
             '2e319b85e70a707bba0beff866d9f9de032aa4f9',
             '786facd2c61deb9cf91e9534735124fb8fc11842',
             '94593d2128d38210a2fcd1aabff6dda0d6d9edf8',
             'aa6a0de05b7612707db567078e130a6cd114a9a7',
             'eada5a770da98ab0dd7325e29d00e0714f228d09'
         ])
         assert subset.issubset(set(self.repo.commit_ids))
 
         # check if we have the proper order of commits
         org = [
             'b986218ba1c9b0d6a259fac9b050b1724ed8e545',
             '3d8f361e72ab303da48d799ff1ac40d5ac37c67e',
             '6cba7170863a2411822803fa77a0a264f1310b35',
             '56349e29c2af3ac913b28bde9a2c6154436e615b',
             '2dda4e345facb0ccff1a191052dd1606dba6781d',
             '6fff84722075f1607a30f436523403845f84cd9e',
             '7d4bc8ec6be56c0f10425afb40b6fc315a4c25e7',
             '3803844fdbd3b711175fc3da9bdacfcd6d29a6fb',
             'dc5d2c0661b61928834a785d3e64a3f80d3aad9c',
             'be90031137367893f1c406e0a8683010fd115b79',
             'db8e58be770518cbb2b1cdfa69146e47cd481481',
             '84478366594b424af694a6c784cb991a16b87c21',
             '17f8e105dddb9f339600389c6dc7175d395a535c',
             '20a662e756499bde3095ffc9bc0643d1def2d0eb',
             '2e319b85e70a707bba0beff866d9f9de032aa4f9',
             '786facd2c61deb9cf91e9534735124fb8fc11842',
             '94593d2128d38210a2fcd1aabff6dda0d6d9edf8',
             'aa6a0de05b7612707db567078e130a6cd114a9a7',
             'eada5a770da98ab0dd7325e29d00e0714f228d09',
             '2c1885c735575ca478bf9e17b0029dca68824458',
             'd9bcd465040bf869799b09ad732c04e0eea99fe9',
             '469e9c847fe1f6f7a697b8b25b4bc5b48780c1a7',
             '4fb8326d78e5120da2c7468dcf7098997be385da',
             '62b4a097164940bd66030c4db51687f3ec035eed',
             '536c1a19428381cfea92ac44985304f6a8049569',
             '965e8ab3c44b070cdaa5bf727ddef0ada980ecc4',
             '9bb326a04ae5d98d437dece54be04f830cf1edd9',
             'f8940bcb890a98c4702319fbe36db75ea309b475',
             'ff5ab059786ebc7411e559a2cc309dfae3625a3b',
             '6b6ad5f82ad5bb6190037671bd254bd4e1f4bf08',
             'ee87846a61c12153b51543bf860e1026c6d3dcba',
         ]
         assert org == self.repo.commit_ids[:31]
 
     def test_iter_slice(self):
         sliced = list(self.repo[:10])
         itered = list(self.repo)[:10]
         assert sliced == itered
 
     def test_slicing(self):
         # 4 1 5 10 95
         for sfrom, sto, size in [(0, 4, 4), (1, 2, 1), (10, 15, 5),
                                  (10, 20, 10), (5, 100, 95)]:
             indexes = list(self.repo[sfrom:sto])
             assert len(indexes) == size
             assert indexes[0] == self.repo.get_commit(commit_idx=sfrom)
             assert indexes[-1] == self.repo.get_commit(commit_idx=sto - 1)
 
     def test_branches(self):
         # TODO: Need more tests here
 
         # active branches
         assert 'default' in self.repo.branches
         assert 'stable' in self.repo.branches
 
         # closed
         assert 'git' in self.repo._get_branches(closed=True)
         assert 'web' in self.repo._get_branches(closed=True)
 
         for name, id in self.repo.branches.items():
             assert isinstance(self.repo.get_commit(id), MercurialCommit)
 
     def test_tip_in_tags(self):
         # tip is always a tag
         assert 'tip' in self.repo.tags
 
     def test_tip_commit_in_tags(self):
         tip = self.repo.get_commit()
         assert self.repo.tags['tip'] == tip.raw_id
 
     def test_initial_commit(self):
         init_commit = self.repo.get_commit(commit_idx=0)
         init_author = init_commit.author
 
         assert init_commit.message == 'initial import'
         assert init_author == 'Marcin Kuzminski <[e-mail]>'
         assert init_author == init_commit.committer
         assert sorted(init_commit._file_paths) == sorted([
             'vcs/__init__.py',
             'vcs/backends/BaseRepository.py',
             'vcs/backends/__init__.py',
         ])
         assert sorted(init_commit._dir_paths) == sorted(
             ['', 'vcs', 'vcs/backends'])
 
         assert init_commit._dir_paths + init_commit._file_paths == \
             init_commit._paths
 
         with pytest.raises(NodeDoesNotExistError):
             init_commit.get_node(path='foobar')
 
         node = init_commit.get_node('vcs/')
         assert hasattr(node, 'kind')
         assert node.kind == NodeKind.DIR
 
         node = init_commit.get_node('vcs')
         assert hasattr(node, 'kind')
         assert node.kind == NodeKind.DIR
 
         node = init_commit.get_node('vcs/__init__.py')
         assert hasattr(node, 'kind')
         assert node.kind == NodeKind.FILE
 
     def test_not_existing_commit(self):
         # rawid
         with pytest.raises(RepositoryError):
             self.repo.get_commit('abcd' * 10)
         # shortid
         with pytest.raises(RepositoryError):
             self.repo.get_commit('erro' * 4)
         # numeric
         with pytest.raises(RepositoryError):
             self.repo.get_commit(commit_idx=self.repo.count() + 1)
 
         # Small chance we ever get to this one
         idx = pow(2, 30)
         with pytest.raises(RepositoryError):
             self.repo.get_commit(commit_idx=idx)
 
     def test_commit10(self):
         commit10 = self.repo.get_commit(commit_idx=10)
         README = """===
 VCS
 ===
 
 Various Version Control System management abstraction layer for Python.
 
 Introduction
 ------------
 
 TODO: To be written...
 
 """
         node = commit10.get_node('README.rst')
         assert node.kind == NodeKind.FILE
         assert node.content == README
 
     def test_local_clone(self):
         clone_path = next(REPO_PATH_GENERATOR)
         self.repo._local_clone(clone_path)
         repo_clone = MercurialRepository(clone_path)
 
         assert self.repo.commit_ids == repo_clone.commit_ids
 
     def test_local_clone_fails_if_target_exists(self):
         with pytest.raises(RepositoryError):
             self.repo._local_clone(self.repo.path)
 
     def test_update(self):
         repo_clone = self.get_clone_repo()
         branches = repo_clone.branches
 
         repo_clone._update('default')
         assert branches['default'] == repo_clone._identify()
         repo_clone._update('stable')
         assert branches['stable'] == repo_clone._identify()
 
     def test_local_pull_branch(self):
         target_repo = self.get_empty_repo()
         source_repo = self.get_clone_repo()
 
         default = Reference(
             'branch', 'default', source_repo.branches['default'])
         target_repo._local_pull(source_repo.path, default)
         target_repo = MercurialRepository(target_repo.path)
         assert (target_repo.branches['default'] ==
                 source_repo.branches['default'])
 
         stable = Reference('branch', 'stable', source_repo.branches['stable'])
         target_repo._local_pull(source_repo.path, stable)
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.branches['stable'] == source_repo.branches['stable']
 
     def test_local_pull_bookmark(self):
         target_repo = self.get_empty_repo()
         source_repo = self.get_clone_repo()
 
         commits = list(source_repo.get_commits(branch_name='default'))
         foo1_id = commits[-5].raw_id
         foo1 = Reference('book', 'foo1', foo1_id)
         source_repo._update(foo1_id)
         source_repo.bookmark('foo1')
 
         foo2_id = commits[-3].raw_id
         foo2 = Reference('book', 'foo2', foo2_id)
         source_repo._update(foo2_id)
         source_repo.bookmark('foo2')
 
         target_repo._local_pull(source_repo.path, foo1)
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.branches['default'] == commits[-5].raw_id
 
         target_repo._local_pull(source_repo.path, foo2)
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.branches['default'] == commits[-3].raw_id
 
     def test_local_pull_commit(self):
         target_repo = self.get_empty_repo()
         source_repo = self.get_clone_repo()
 
         commits = list(source_repo.get_commits(branch_name='default'))
         commit_id = commits[-5].raw_id
         commit = Reference('rev', commit_id, commit_id)
         target_repo._local_pull(source_repo.path, commit)
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.branches['default'] == commit_id
 
         commit_id = commits[-3].raw_id
         commit = Reference('rev', commit_id, commit_id)
         target_repo._local_pull(source_repo.path, commit)
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.branches['default'] == commit_id
 
     def test_local_pull_from_same_repo(self):
         reference = Reference('branch', 'default', None)
         with pytest.raises(ValueError):
             self.repo._local_pull(self.repo.path, reference)
 
     def test_validate_pull_reference_raises_on_missing_reference(
             self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         reference = Reference(
             'book', 'invalid_reference', 'a' * 40)
 
         with pytest.raises(CommitDoesNotExistError):
             target_repo._validate_pull_reference(reference)
 
     def test_heads(self):
         assert set(self.repo._heads()) == set(self.repo.branches.values())
 
     def test_ancestor(self):
         commits = [
             c.raw_id for c in self.repo.get_commits(branch_name='default')]
         assert self.repo._ancestor(commits[-3], commits[-5]) == commits[-5]
         assert self.repo._ancestor(commits[-5], commits[-3]) == commits[-5]
 
     def test_local_push(self):
         target_repo = self.get_empty_repo()
 
         revisions = list(self.repo.get_commits(branch_name='default'))
         revision = revisions[-5].raw_id
         self.repo._local_push(revision, target_repo.path)
 
         target_repo = MercurialRepository(target_repo.path)
 
         assert target_repo.branches['default'] == revision
 
     def test_hooks_can_be_enabled_for_local_push(self):
         revision = 'deadbeef'
         repo_path = 'test_group/test_repo'
         with mock.patch.object(self.repo, '_remote') as remote_mock:
             self.repo._local_push(revision, repo_path, enable_hooks=True)
         remote_mock.push.assert_called_once_with(
             [revision], repo_path, hooks=True, push_branches=False)
 
     def test_local_merge(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         vcsbackend_hg.add_file(target_repo, 'README_MERGE1', 'Version 1')
         target_repo = MercurialRepository(target_repo.path)
         target_rev = target_repo.branches['default']
         target_ref = Reference(
             type='branch', name='default', commit_id=target_rev)
         vcsbackend_hg.add_file(source_repo, 'README_MERGE2', 'Version 2')
         source_repo = MercurialRepository(source_repo.path)
         source_rev = source_repo.branches['default']
         source_ref = Reference(
             type='branch', name='default', commit_id=source_rev)
 
         target_repo._local_pull(source_repo.path, source_ref)
 
         merge_message = 'Merge message\n\nDescription:...'
         user_name = 'Albert Einstein'
         user_email = '[e-mail]'
         merge_commit_id, needs_push = target_repo._local_merge(
             target_ref, merge_message, user_name, user_email, source_ref)
         assert needs_push
 
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.commit_ids[-3] == target_rev
         assert target_repo.commit_ids[-2] == source_rev
         last_commit = target_repo.get_commit(merge_commit_id)
         assert last_commit.message.strip() == merge_message
         assert last_commit.author == '%s <%s>' % (user_name, user_email)
 
         assert not os.path.exists(
             os.path.join(target_repo.path, '.hg', 'merge', 'state'))
 
     def test_local_merge_source_is_fast_forward(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         target_rev = target_repo.branches['default']
         target_ref = Reference(
             type='branch', name='default', commit_id=target_rev)
         vcsbackend_hg.add_file(source_repo, 'README_MERGE2', 'Version 2')
         source_repo = MercurialRepository(source_repo.path)
         source_rev = source_repo.branches['default']
         source_ref = Reference(
             type='branch', name='default', commit_id=source_rev)
 
         target_repo._local_pull(source_repo.path, source_ref)
 
         merge_message = 'Merge message\n\nDescription:...'
         user_name = 'Albert Einstein'
         user_email = '[e-mail]'
         merge_commit_id, needs_push = target_repo._local_merge(
             target_ref, merge_message, user_name, user_email, source_ref)
         assert merge_commit_id == source_rev
         assert needs_push
 
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.commit_ids[-2] == target_rev
         assert target_repo.commit_ids[-1] == source_rev
 
         assert not os.path.exists(
             os.path.join(target_repo.path, '.hg', 'merge', 'state'))
 
     def test_local_merge_source_is_integrated(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         target_rev = target_repo.branches['default']
         target_ref = Reference(
             type='branch', name='default', commit_id=target_rev)
 
         merge_message = 'Merge message\n\nDescription:...'
         user_name = 'Albert Einstein'
         user_email = '[e-mail]'
         merge_commit_id, needs_push = target_repo._local_merge(
             target_ref, merge_message, user_name, user_email, target_ref)
         assert merge_commit_id == target_rev
         assert not needs_push
 
         target_repo = MercurialRepository(target_repo.path)
         assert target_repo.commit_ids[-1] == target_rev
 
         assert not os.path.exists(
             os.path.join(target_repo.path, '.hg', 'merge', 'state'))
 
     def test_local_merge_raises_exception_on_conflict(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         vcsbackend_hg.add_file(target_repo, 'README_MERGE', 'Version 1')
         target_repo = MercurialRepository(target_repo.path)
         target_rev = target_repo.branches['default']
         target_ref = Reference(
             type='branch', name='default', commit_id=target_rev)
         vcsbackend_hg.add_file(source_repo, 'README_MERGE', 'Version 2')
         source_repo = MercurialRepository(source_repo.path)
         source_rev = source_repo.branches['default']
         source_ref = Reference(
             type='branch', name='default', commit_id=source_rev)
 
         target_repo._local_pull(source_repo.path, source_ref)
         with pytest.raises(RepositoryError):
             target_repo._local_merge(
                 target_ref, 'merge_message', 'user name', '[e-mail]',
                 source_ref)
 
         # Check we are not left in an intermediate merge state
         assert not os.path.exists(
             os.path.join(target_repo.path, '.hg', 'merge', 'state'))
 
     def test_local_merge_of_two_branches_of_the_same_repo(self, backend_hg):
         commits = [
             {'message': 'a'},
             {'message': 'b', 'branch': 'b'},
         ]
         repo = backend_hg.create_repo(commits)
         commit_ids = backend_hg.commit_ids
         target_ref = Reference(
             type='branch', name='default', commit_id=commit_ids['a'])
         source_ref = Reference(
             type='branch', name='b', commit_id=commit_ids['b'])
         merge_message = 'Merge message\n\nDescription:...'
         user_name = 'Albert Einstein'
         user_email = '[e-mail]'
         vcs_repo = repo.scm_instance()
         merge_commit_id, needs_push = vcs_repo._local_merge(
             target_ref, merge_message, user_name, user_email, source_ref)
         assert merge_commit_id != source_ref.commit_id
         assert needs_push is True
         commit = vcs_repo.get_commit(merge_commit_id)
         assert commit.merge is True
         assert commit.message == merge_message
 
     def test_maybe_prepare_merge_workspace(self):
         workspace = self.repo._maybe_prepare_merge_workspace(
             1, 'pr2', 'unused', 'unused2')
 
         assert os.path.isdir(workspace)
         workspace_repo = MercurialRepository(workspace)
         assert workspace_repo.branches == self.repo.branches
 
         # Calling it a second time should also succeed
         workspace = self.repo._maybe_prepare_merge_workspace(
             1, 'pr2', 'unused', 'unused2')
         assert os.path.isdir(workspace)
 
     def test_cleanup_merge_workspace(self):
         workspace = self.repo._maybe_prepare_merge_workspace(
             1, 'pr3', 'unused', 'unused2')
 
         assert os.path.isdir(workspace)
         self.repo.cleanup_merge_workspace(1, 'pr3')
 
         assert not os.path.exists(workspace)
 
     def test_cleanup_merge_workspace_invalid_workspace_id(self):
         # No assert: because in case of an inexistent workspace this function
         # should still succeed.
         self.repo.cleanup_merge_workspace(1, 'pr4')
 
     def test_merge_target_is_bookmark(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         vcsbackend_hg.add_file(target_repo, 'README_MERGE1', 'Version 1')
         vcsbackend_hg.add_file(source_repo, 'README_MERGE2', 'Version 2')
         imc = source_repo.in_memory_commit
         imc.add(FileNode('file_x', content=source_repo.name))
         imc.commit(
             message=u'Automatic commit from repo merge test',
             author=u'Automatic')
         target_commit = target_repo.get_commit()
         source_commit = source_repo.get_commit()
         default_branch = target_repo.DEFAULT_BRANCH_NAME
         bookmark_name = 'bookmark'
         target_repo._update(default_branch)
         target_repo.bookmark(bookmark_name)
         target_ref = Reference('book', bookmark_name, target_commit.raw_id)
         source_ref = Reference('branch', default_branch, source_commit.raw_id)
         workspace_id = 'test-merge'
         repo_id = repo_id_generator(target_repo.path)
         merge_response = target_repo.merge(
             repo_id, workspace_id, target_ref, source_repo, source_ref,
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False)
         expected_merge_response = MergeResponse(
             True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
         target_repo = backends.get_backend(vcsbackend_hg.alias)(
             target_repo.path)
         target_commits = list(target_repo.get_commits())
         commit_ids = [c.raw_id for c in target_commits[:-1]]
         assert source_ref.commit_id in commit_ids
         assert target_ref.commit_id in commit_ids
 
         merge_commit = target_commits[-1]
         assert merge_commit.raw_id == merge_response.merge_ref.commit_id
         assert merge_commit.message.strip() == 'merge message 1'
         assert merge_commit.author == 'test user <[e-mail]>'
 
         # Check the bookmark was updated in the target repo
         assert (
             target_repo.bookmarks[bookmark_name] ==
             merge_response.merge_ref.commit_id)
 
     def test_merge_source_is_bookmark(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         imc = source_repo.in_memory_commit
         imc.add(FileNode('file_x', content=source_repo.name))
         imc.commit(
             message=u'Automatic commit from repo merge test',
             author=u'Automatic')
         target_commit = target_repo.get_commit()
         source_commit = source_repo.get_commit()
         default_branch = target_repo.DEFAULT_BRANCH_NAME
         bookmark_name = 'bookmark'
         target_ref = Reference('branch', default_branch, target_commit.raw_id)
         source_repo._update(default_branch)
         source_repo.bookmark(bookmark_name)
         source_ref = Reference('book', bookmark_name, source_commit.raw_id)
         workspace_id = 'test-merge'
         repo_id = repo_id_generator(target_repo.path)
         merge_response = target_repo.merge(
             repo_id, workspace_id, target_ref, source_repo, source_ref,
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False)
         expected_merge_response = MergeResponse(
             True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
         target_repo = backends.get_backend(vcsbackend_hg.alias)(
             target_repo.path)
         target_commits = list(target_repo.get_commits())
         commit_ids = [c.raw_id for c in target_commits]
         assert source_ref.commit_id == commit_ids[-1]
         assert target_ref.commit_id == commit_ids[-2]
 
     def test_merge_target_has_multiple_heads(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=2)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         vcsbackend_hg.add_file(target_repo, 'README_MERGE1', 'Version 1')
         vcsbackend_hg.add_file(source_repo, 'README_MERGE2', 'Version 2')
 
         # add an extra head to the target repo
         imc = target_repo.in_memory_commit
         imc.add(FileNode('file_x', content='foo'))
         commits = list(target_repo.get_commits())
         imc.commit(
             message=u'Automatic commit from repo merge test',
             author=u'Automatic', parents=commits[0:1])
 
         target_commit = target_repo.get_commit()
         source_commit = source_repo.get_commit()
         default_branch = target_repo.DEFAULT_BRANCH_NAME
         target_repo._update(default_branch)
 
         target_ref = Reference('branch', default_branch, target_commit.raw_id)
         source_ref = Reference('branch', default_branch, source_commit.raw_id)
         workspace_id = 'test-merge'
 
         assert len(target_repo._heads(branch='default')) == 2
         expected_merge_response = MergeResponse(
             False, False, None,
             MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS)
         repo_id = repo_id_generator(target_repo.path)
         merge_response = target_repo.merge(
             repo_id, workspace_id, target_ref, source_repo, source_ref,
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False)
         assert merge_response == expected_merge_response
 
     def test_merge_rebase_source_is_updated_bookmark(self, vcsbackend_hg):
         target_repo = vcsbackend_hg.create_repo(number_of_commits=1)
         source_repo = vcsbackend_hg.clone_repo(target_repo)
         vcsbackend_hg.add_file(target_repo, 'README_MERGE1', 'Version 1')
         vcsbackend_hg.add_file(source_repo, 'README_MERGE2', 'Version 2')
         imc = source_repo.in_memory_commit
         imc.add(FileNode('file_x', content=source_repo.name))
         imc.commit(
             message=u'Automatic commit from repo merge test',
             author=u'Automatic')
         target_commit = target_repo.get_commit()
         source_commit = source_repo.get_commit()
 
         vcsbackend_hg.add_file(source_repo, 'LICENSE', 'LICENSE Info')
 
         default_branch = target_repo.DEFAULT_BRANCH_NAME
         bookmark_name = 'bookmark'
         source_repo._update(default_branch)
         source_repo.bookmark(bookmark_name)
 
         target_ref = Reference('branch', default_branch, target_commit.raw_id)
         source_ref = Reference('book', bookmark_name, source_commit.raw_id)
         repo_id = repo_id_generator(target_repo.path)
         workspace_id = 'test-merge'
 
         merge_response = target_repo.merge(
             repo_id, workspace_id, target_ref, source_repo, source_ref,
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False, use_rebase=True)
 
         expected_merge_response = MergeResponse(
             True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
         target_repo = backends.get_backend(vcsbackend_hg.alias)(
             target_repo.path)
         last_commit = target_repo.get_commit()
         assert last_commit.message == source_commit.message
         assert last_commit.author == source_commit.author
         # This checks that we effectively did a rebase
         assert last_commit.raw_id != source_commit.raw_id
 
         # Check the target has only 4 commits: 2 were already in target and
         # only two should have been added
         assert len(target_repo.commit_ids) == 2 + 2
 
 
 class TestGetShadowInstance(object):
 
     @pytest.fixture
     def repo(self, vcsbackend_hg, monkeypatch):
         repo = vcsbackend_hg.repo
         monkeypatch.setattr(repo, 'config', mock.Mock())
         monkeypatch.setattr('rhodecode.lib.vcs.connection.Hg', mock.Mock())
         return repo
 
     def test_passes_config(self, repo):
         shadow = repo._get_shadow_instance(repo.path)
         assert shadow.config == repo.config.copy()
 
     def test_disables_hooks(self, repo):
         shadow = repo._get_shadow_instance(repo.path)
         shadow.config.clear_section.assert_called_once_with('hooks')
 
     def test_allows_to_keep_hooks(self, repo):
         shadow = repo._get_shadow_instance(repo.path, enable_hooks=True)
         assert not shadow.config.clear_section.called
 
 
 class TestMercurialCommit(object):
 
     def _test_equality(self, commit):
         idx = commit.idx
         assert commit == self.repo.get_commit(commit_idx=idx)
 
     def test_equality(self):
         indexes = [0, 10, 20]
         commits = [self.repo.get_commit(commit_idx=idx) for idx in indexes]
         for commit in commits:
             self._test_equality(commit)
 
     def test_default_commit(self):
         tip = self.repo.get_commit('tip')
         assert tip == self.repo.get_commit()
         assert tip == self.repo.get_commit(commit_id=None)
         assert tip == self.repo.get_commit(commit_idx=None)
         assert tip == list(self.repo[-1:])[0]
 
     def test_root_node(self):
         tip = self.repo.get_commit('tip')
         assert tip.root is tip.get_node('')
 
     def test_lazy_fetch(self):
         """
         Test if commit's nodes expands and are cached as we walk through
         the commit. This test is somewhat hard to write as order of tests
         is a key here. Written by running command after command in a shell.
         """
         commit = self.repo.get_commit(commit_idx=45)
         assert len(commit.nodes) == 0
         root = commit.root
         assert len(commit.nodes) == 1
         assert len(root.nodes) == 8
         # accessing root.nodes updates commit.nodes
         assert len(commit.nodes) == 9
 
         docs = root.get_node('docs')
         # we haven't yet accessed anything new as docs dir was already cached
         assert len(commit.nodes) == 9
         assert len(docs.nodes) == 8
         # accessing docs.nodes updates commit.nodes
         assert len(commit.nodes) == 17
 
         assert docs is commit.get_node('docs')
         assert docs is root.nodes[0]
         assert docs is root.dirs[0]
         assert docs is commit.get_node('docs')
 
     def test_nodes_with_commit(self):
         commit = self.repo.get_commit(commit_idx=45)
         root = commit.root
         docs = root.get_node('docs')
         assert docs is commit.get_node('docs')
         api = docs.get_node('api')
         assert api is commit.get_node('docs/api')
         index = api.get_node('index.rst')
         assert index is commit.get_node('docs/api/index.rst')
         assert index is commit.get_node(
             'docs').get_node('api').get_node('index.rst')
 
     def test_branch_and_tags(self):
         commit0 = self.repo.get_commit(commit_idx=0)
         assert commit0.branch == 'default'
         assert commit0.tags == []
 
         commit10 = self.repo.get_commit(commit_idx=10)
         assert commit10.branch == 'default'
         assert commit10.tags == []
 
         commit44 = self.repo.get_commit(commit_idx=44)
         assert commit44.branch == 'web'
 
         tip = self.repo.get_commit('tip')
         assert 'tip' in tip.tags
 
     def test_bookmarks(self):
         commit0 = self.repo.get_commit(commit_idx=0)
         assert commit0.bookmarks == []
 
     def _test_file_size(self, idx, path, size):
         node = self.repo.get_commit(commit_idx=idx).get_node(path)
         assert node.is_file()
         assert node.size == size
 
     def test_file_size(self):
         to_check = (
             (10, 'setup.py', 1068),
             (20, 'setup.py', 1106),
             (60, 'setup.py', 1074),
 
             (10, 'vcs/backends/base.py', 2921),
             (20, 'vcs/backends/base.py', 3936),
             (60, 'vcs/backends/base.py', 6189),
         )
         for idx, path, size in to_check:
             self._test_file_size(idx, path, size)
 
     def test_file_history_from_commits(self):
         node = self.repo[10].get_node('setup.py')
         commit_ids = [commit.raw_id for commit in node.history]
         assert ['3803844fdbd3b711175fc3da9bdacfcd6d29a6fb'] == commit_ids
 
         node = self.repo[20].get_node('setup.py')
         node_ids = [commit.raw_id for commit in node.history]
         assert ['eada5a770da98ab0dd7325e29d00e0714f228d09',
                 '3803844fdbd3b711175fc3da9bdacfcd6d29a6fb'] == node_ids
 
         # special case we check history from commit that has this particular
         # file changed this means we check if it's included as well
         node = self.repo.get_commit('eada5a770da98ab0dd7325e29d00e0714f228d09')\
             .get_node('setup.py')
         node_ids = [commit.raw_id for commit in node.history]
         assert ['eada5a770da98ab0dd7325e29d00e0714f228d09',
                 '3803844fdbd3b711175fc3da9bdacfcd6d29a6fb'] == node_ids
 
     def test_file_history(self):
         # we can only check if those commits are present in the history
         # as we cannot update this test every time file is changed
         files = {
             'setup.py': [7, 18, 45, 46, 47, 69, 77],
             'vcs/nodes.py': [
                 7, 8, 24, 26, 30, 45, 47, 49, 56, 57, 58, 59, 60, 61, 73, 76],
             'vcs/backends/hg.py': [
                 4, 5, 6, 11, 12, 13, 14, 15, 16, 21, 22, 23, 26, 27, 28, 30,
                 31, 33, 35, 36, 37, 38, 39, 40, 41, 44, 45, 47, 48, 49, 53, 54,
                 55, 58, 60, 61, 67, 68, 69, 70, 73, 77, 78, 79, 82],
         }
         for path, indexes in files.items():
             tip = self.repo.get_commit(commit_idx=indexes[-1])
             node = tip.get_node(path)
             node_indexes = [commit.idx for commit in node.history]
             assert set(indexes).issubset(set(node_indexes)), (
                 "We assumed that %s is subset of commits for which file %s "
                 "has been changed, and history of that node returned: %s"
                 % (indexes, path, node_indexes))
 
     def test_file_annotate(self):
         files = {
             'vcs/backends/__init__.py': {
                 89: {
                     'lines_no': 31,
                     'commits': [
                         32, 32, 61, 32, 32, 37, 32, 32, 32, 44,
                         37, 37, 37, 37, 45, 37, 44, 37, 37, 37,
                         32, 32, 32, 32, 37, 32, 37, 37, 32,
                         32, 32
                     ]
                 },
                 20: {
                     'lines_no': 1,
                     'commits': [4]
                 },
                 55: {
                     'lines_no': 31,
                     'commits': [
                         32, 32, 45, 32, 32, 37, 32, 32, 32, 44,
                         37, 37, 37, 37, 45, 37, 44, 37, 37, 37,
                         32, 32, 32, 32, 37, 32, 37, 37, 32,
                         32, 32
                     ]
                 }
             },
             'vcs/exceptions.py': {
                 89: {
                     'lines_no': 18,
                     'commits': [
                         16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
                         16, 16, 17, 16, 16, 18, 18, 18
                     ]
                 },
                 20: {
                     'lines_no': 18,
                     'commits': [
                         16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
                         16, 16, 17, 16, 16, 18, 18, 18
                     ]
                 },
                 55: {
                     'lines_no': 18,
                     'commits': [
                         16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
                         17, 16, 16, 18, 18, 18
                     ]
                 }
             },
             'MANIFEST.in': {
                 89: {
                     'lines_no': 5,
                     'commits': [7, 7, 7, 71, 71]
                 },
                 20: {
                     'lines_no': 3,
                     'commits': [7, 7, 7]
                 },
                 55: {
                     'lines_no': 3,
                     'commits': [7, 7, 7]
                 }
             }
         }
 
         for fname, commit_dict in files.items():
             for idx, __ in commit_dict.items():
                 commit = self.repo.get_commit(commit_idx=idx)
                 l1_1 = [x[1] for x in commit.get_file_annotate(fname)]
                 l1_2 = [x[2]().raw_id for x in commit.get_file_annotate(fname)]
                 assert l1_1 == l1_2
                 l1 = l1_2 = [
                     x[2]().idx for x in commit.get_file_annotate(fname)]
                 l2 = files[fname][idx]['commits']
                 assert l1 == l2, (
                     "The lists of commit for %s@commit_id%s"
                     "from annotation list should match each other,"
                     "got \n%s \nvs \n%s " % (fname, idx, l1, l2))
 
     def test_commit_state(self):
         """
         Tests which files have been added/changed/removed at particular commit
         """
 
         # commit_id 46ad32a4f974:
         # hg st --rev 46ad32a4f974
         #    changed: 13
         #    added:   20
         #    removed: 1
         changed = set([
             '.hgignore', 'README.rst', 'docs/conf.py', 'docs/index.rst',
             'setup.py', 'tests/test_hg.py', 'tests/test_nodes.py',
             'vcs/__init__.py', 'vcs/backends/__init__.py',
             'vcs/backends/base.py', 'vcs/backends/hg.py', 'vcs/nodes.py',
             'vcs/utils/__init__.py'])
 
         added = set([
             'docs/api/backends/hg.rst', 'docs/api/backends/index.rst',
             'docs/api/index.rst', 'docs/api/nodes.rst',
             'docs/api/web/index.rst', 'docs/api/web/simplevcs.rst',
             'docs/installation.rst', 'docs/quickstart.rst', 'setup.cfg',
             'vcs/utils/baseui_config.py', 'vcs/utils/web.py',
             'vcs/web/__init__.py', 'vcs/web/exceptions.py',
             'vcs/web/simplevcs/__init__.py', 'vcs/web/simplevcs/exceptions.py',
             'vcs/web/simplevcs/middleware.py', 'vcs/web/simplevcs/models.py',
             'vcs/web/simplevcs/settings.py', 'vcs/web/simplevcs/utils.py',
             'vcs/web/simplevcs/views.py'])
 
         removed = set(['docs/api.rst'])
 
         commit64 = self.repo.get_commit('46ad32a4f974')
         assert set((node.path for node in commit64.added)) == added
         assert set((node.path for node in commit64.changed)) == changed
         assert set((node.path for node in commit64.removed)) == removed
 
         # commit_id b090f22d27d6:
         # hg st --rev b090f22d27d6
         #    changed: 13
         #    added:   20
         #    removed: 1
         commit88 = self.repo.get_commit('b090f22d27d6')
         assert set((node.path for node in commit88.added)) == set()
         assert set((node.path for node in commit88.changed)) == \
             set(['.hgignore'])
         assert set((node.path for node in commit88.removed)) == set()
 
         #
         # 85:
         #    added:   2 [
         #       'vcs/utils/diffs.py', 'vcs/web/simplevcs/views/diffs.py']
         #    changed: 4 ['vcs/web/simplevcs/models.py', ...]
         #    removed: 1 ['vcs/utils/web.py']
         commit85 = self.repo.get_commit(commit_idx=85)
         assert set((node.path for node in commit85.added)) == set([
             'vcs/utils/diffs.py',
             'vcs/web/simplevcs/views/diffs.py'])
         assert set((node.path for node in commit85.changed)) == set([
             'vcs/web/simplevcs/models.py',
             'vcs/web/simplevcs/utils.py',
             'vcs/web/simplevcs/views/__init__.py',
             'vcs/web/simplevcs/views/repository.py',
             ])
         assert set((node.path for node in commit85.removed)) == \
             set(['vcs/utils/web.py'])
 
     def test_files_state(self):
         """
         Tests state of FileNodes.
         """
         commit = self.repo.get_commit(commit_idx=85)
         node = commit.get_node('vcs/utils/diffs.py')
         assert node.state, NodeState.ADDED
         assert node.added
         assert not node.changed
         assert not node.not_changed
         assert not node.removed
 
         commit = self.repo.get_commit(commit_idx=88)
         node = commit.get_node('.hgignore')
         assert node.state, NodeState.CHANGED
         assert not node.added
         assert node.changed
         assert not node.not_changed
         assert not node.removed
 
         commit = self.repo.get_commit(commit_idx=85)
         node = commit.get_node('setup.py')
         assert node.state, NodeState.NOT_CHANGED
         assert not node.added
         assert not node.changed
         assert node.not_changed
         assert not node.removed
 
         # If node has REMOVED state then trying to fetch it would raise
         # CommitError exception
         commit = self.repo.get_commit(commit_idx=2)
         path = 'vcs/backends/BaseRepository.py'
         with pytest.raises(NodeDoesNotExistError):
             commit.get_node(path)
         # but it would be one of ``removed`` (commit's attribute)
         assert path in [rf.path for rf in commit.removed]
 
     def test_commit_message_is_unicode(self):
         for cm in self.repo:
             assert type(cm.message) == unicode
 
     def test_commit_author_is_unicode(self):
         for cm in self.repo:
             assert type(cm.author) == unicode
 
     def test_repo_files_content_is_unicode(self):
         test_commit = self.repo.get_commit(commit_idx=100)
         for node in test_commit.get_node('/'):
             if node.is_file():
                 assert type(node.content) == unicode
 
     def test_wrong_path(self):
         # There is 'setup.py' in the root dir but not there:
         path = 'foo/bar/setup.py'
         with pytest.raises(VCSError):
             self.repo.get_commit().get_node(path)
 
     def test_author_email(self):
         assert '[e-mail]' == \
             self.repo.get_commit('b986218ba1c9').author_email
         assert '[e-mail]' == \
             self.repo.get_commit('3803844fdbd3').author_email
         assert '' == self.repo.get_commit('84478366594b').author_email
 
     def test_author_username(self):
         assert 'Marcin Kuzminski' == \
             self.repo.get_commit('b986218ba1c9').author_name
         assert 'Lukasz Balcerzak' == \
             self.repo.get_commit('3803844fdbd3').author_name
         assert 'marcink' == \
             self.repo.get_commit('84478366594b').author_name
 
 
 class TestLargeFileRepo(object):
 
     def test_large_file(self, backend_hg):
         repo = backend_hg.create_test_repo('largefiles', make_db_config())
 
         tip = repo.scm_instance().get_commit()
         node = tip.get_node('.hglf/thisfileislarge')
 
         lf_node = node.get_largefile_node()
 
         assert lf_node.is_largefile() is True
         assert lf_node.size == 1024000
         assert lf_node.name == '.hglf/thisfileislarge'
 
 
 class TestGetBranchName(object):
     def test_returns_ref_name_when_type_is_branch(self):
         ref = self._create_ref('branch', 'fake-name')
         result = self.repo._get_branch_name(ref)
         assert result == ref.name
 
     @pytest.mark.parametrize("type_", ("book", "tag"))
     def test_queries_remote_when_type_is_not_branch(self, type_):
         ref = self._create_ref(type_, 'wrong-fake-name')
         with mock.patch.object(self.repo, "_remote") as remote_mock:
             remote_mock.ctx_branch.return_value = "fake-name"
             result = self.repo._get_branch_name(ref)
         assert result == "fake-name"
         remote_mock.ctx_branch.assert_called_once_with(ref.commit_id)
 
     def _create_ref(self, type_, name):
         ref = mock.Mock()
         ref.type = type_
         ref.name = 'wrong-fake-name'
         ref.commit_id = "deadbeef"
         return ref
 
 
 class TestIsTheSameBranch(object):
     def test_returns_true_when_branches_are_equal(self):
         source_ref = mock.Mock(name="source-ref")
         target_ref = mock.Mock(name="target-ref")
         branch_name_patcher = mock.patch.object(
             self.repo, "_get_branch_name", return_value="default")
         with branch_name_patcher as branch_name_mock:
             result = self.repo._is_the_same_branch(source_ref, target_ref)
 
         expected_calls = [mock.call(source_ref), mock.call(target_ref)]
         assert branch_name_mock.call_args_list == expected_calls
         assert result is True
 
     def test_returns_false_when_branches_are_not_equal(self):
         source_ref = mock.Mock(name="source-ref")
         source_ref.name = "source-branch"
         target_ref = mock.Mock(name="target-ref")
         source_ref.name = "target-branch"
 
         def side_effect(ref):
             return ref.name
 
         branch_name_patcher = mock.patch.object(
             self.repo, "_get_branch_name", side_effect=side_effect)
         with branch_name_patcher as branch_name_mock:
             result = self.repo._is_the_same_branch(source_ref, target_ref)
 
         expected_calls = [mock.call(source_ref), mock.call(target_ref)]
         assert branch_name_mock.call_args_list == expected_calls
         assert result is False