tests: multiple tests cases fixes for python3

rhodecode/apps/my_account/tests/test_my_account_simple_views.py

@@ -1,76 +1,75 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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.apps._base import ADMIN_PREFIX
 from rhodecode.model.db import User, UserEmailMap, Repository, UserFollowing
 from rhodecode.tests import (
     TestController, TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_EMAIL,
     assert_session_flash)
 from rhodecode.tests.fixture import Fixture
 
 fixture = Fixture()
 
 
 def route_path(name, **kwargs):
     return {
         'my_account_repos':
             ADMIN_PREFIX + '/my_account/repos',
         'my_account_watched':
             ADMIN_PREFIX + '/my_account/watched',
         'my_account_perms':
             ADMIN_PREFIX + '/my_account/perms',
         'my_account_notifications':
             ADMIN_PREFIX + '/my_account/notifications',
     }[name].format(**kwargs)
 
 
 class TestMyAccountSimpleViews(TestController):
 
     def test_my_account_my_repos(self, autologin_user):
         response = self.app.get(route_path('my_account_repos'))
         repos = Repository.query().filter(
             Repository.user == User.get_by_username(
                 TEST_USER_ADMIN_LOGIN)).all()
         for repo in repos:
-            response.mustcontain('"name_raw": "%s"' % repo.repo_name)
+            response.mustcontain(f'"name_raw":"{repo.repo_name}"')
 
     def test_my_account_my_watched(self, autologin_user):
         response = self.app.get(route_path('my_account_watched'))
 
         repos = UserFollowing.query().filter(
             UserFollowing.user == User.get_by_username(
                 TEST_USER_ADMIN_LOGIN)).all()
         for repo in repos:
-            response.mustcontain(
-                '"name_raw": "%s"' % repo.follows_repository.repo_name)
+            response.mustcontain(f'"name_raw":"{repo.follows_repository.repo_name}"')
 
     def test_my_account_perms(self, autologin_user):
         response = self.app.get(route_path('my_account_perms'))
         assert_response = response.assert_response()
         assert assert_response.get_elements('.perm_tag.none')
         assert assert_response.get_elements('.perm_tag.read')
         assert assert_response.get_elements('.perm_tag.write')
         assert assert_response.get_elements('.perm_tag.admin')
 
     def test_my_account_notifications(self, autologin_user):
         response = self.app.get(route_path('my_account_notifications'))
         response.mustcontain('Test flash message')

rhodecode/apps/repository/tests/test_repo_changelog.py

@@ -1,220 +1,220 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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 re
 
 import pytest
 
 from rhodecode.apps.repository.views.repo_changelog import DEFAULT_CHANGELOG_SIZE
 from rhodecode.tests import TestController
 
 MATCH_HASH = re.compile(r'<span class="commit_hash">r(\d+):[\da-f]+</span>')
 
 
 def route_path(name, params=None, **kwargs):
     import urllib.request, urllib.parse, urllib.error
 
     base_url = {
         'repo_changelog': '/{repo_name}/changelog',
         'repo_commits': '/{repo_name}/commits',
         'repo_commits_file': '/{repo_name}/commits/{commit_id}/{f_path}',
         'repo_commits_elements': '/{repo_name}/commits_elements',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
     return base_url
 
 
 def assert_commits_on_page(response, indexes):
     found_indexes = [int(idx) for idx in MATCH_HASH.findall(response.body)]
     assert found_indexes == indexes
 
 
 class TestChangelogController(TestController):
 
     def test_commits_page(self, backend):
         self.log_user()
         response = self.app.get(
             route_path('repo_commits', repo_name=backend.repo_name))
 
         first_idx = -1
         last_idx = -DEFAULT_CHANGELOG_SIZE
         self.assert_commit_range_on_page(response, first_idx, last_idx, backend)
 
     def test_changelog(self, backend):
         self.log_user()
         response = self.app.get(
             route_path('repo_changelog', repo_name=backend.repo_name))
 
         first_idx = -1
         last_idx = -DEFAULT_CHANGELOG_SIZE
         self.assert_commit_range_on_page(
             response, first_idx, last_idx, backend)
 
     @pytest.mark.backends("hg", "git")
     def test_changelog_filtered_by_branch(self, backend):
         self.log_user()
         self.app.get(
             route_path('repo_changelog', repo_name=backend.repo_name,
                        params=dict(branch=backend.default_branch_name)),
             status=200)
 
     @pytest.mark.backends("hg", "git")
     def test_commits_filtered_by_branch(self, backend):
         self.log_user()
         self.app.get(
             route_path('repo_commits', repo_name=backend.repo_name,
                        params=dict(branch=backend.default_branch_name)),
             status=200)
 
     @pytest.mark.backends("svn")
     def test_changelog_filtered_by_branch_svn(self, autologin_user, backend):
         repo = backend['svn-simple-layout']
         response = self.app.get(
             route_path('repo_changelog', repo_name=repo.repo_name,
                        params=dict(branch='trunk')),
             status=200)
 
         assert_commits_on_page(response, indexes=[15, 12, 7, 3, 2, 1])
 
     def test_commits_filtered_by_wrong_branch(self, backend):
         self.log_user()
         branch = 'wrong-branch-name'
         response = self.app.get(
             route_path('repo_commits', repo_name=backend.repo_name,
                        params=dict(branch=branch)),
             status=302)
         expected_url = '/{repo}/commits/{branch}'.format(
             repo=backend.repo_name, branch=branch)
         assert expected_url in response.location
         response = response.follow()
         expected_warning = 'Branch {} is not found.'.format(branch)
-        assert expected_warning in response.body
+        assert expected_warning in response.text
 
     @pytest.mark.xfail_backends("svn", reason="Depends on branch support")
     def test_changelog_filtered_by_branch_with_merges(
             self, autologin_user, backend):
 
         # Note: The changelog of branch "b" does not contain the commit "a1"
         # although this is a parent of commit "b1". And branch "b" has commits
         # which have a smaller index than commit "a1".
         commits = [
             {'message': 'a'},
             {'message': 'b', 'branch': 'b'},
             {'message': 'a1', 'parents': ['a']},
             {'message': 'b1', 'branch': 'b', 'parents': ['b', 'a1']},
         ]
         backend.create_repo(commits)
 
         self.app.get(
             route_path('repo_changelog', repo_name=backend.repo_name,
                        params=dict(branch='b')),
             status=200)
 
     @pytest.mark.backends("hg")
     def test_commits_closed_branches(self, autologin_user, backend):
         repo = backend['closed_branch']
         response = self.app.get(
             route_path('repo_commits', repo_name=repo.repo_name,
                        params=dict(branch='experimental')),
             status=200)
 
         assert_commits_on_page(response, indexes=[3, 1])
 
     def test_changelog_pagination(self, backend):
         self.log_user()
         # pagination, walk up to page 6
         changelog_url = route_path(
             'repo_commits', repo_name=backend.repo_name)
 
         for page in range(1, 7):
             response = self.app.get(changelog_url, {'page': page})
 
         first_idx = -DEFAULT_CHANGELOG_SIZE * (page - 1) - 1
         last_idx = -DEFAULT_CHANGELOG_SIZE * page
         self.assert_commit_range_on_page(response, first_idx, last_idx, backend)
 
     def assert_commit_range_on_page(
             self, response, first_idx, last_idx, backend):
         input_template = (
             """<input class="commit-range" """ 
             """data-commit-id="%(raw_id)s" data-commit-idx="%(idx)s" """ 
             """data-short-id="%(short_id)s" id="%(raw_id)s" """
             """name="%(raw_id)s" type="checkbox" value="1" />"""
         )
 
         commit_span_template = """<span class="commit_hash">r%s:%s</span>"""
         repo = backend.repo
 
         first_commit_on_page = repo.get_commit(commit_idx=first_idx)
         response.mustcontain(
             input_template % {'raw_id': first_commit_on_page.raw_id,
                               'idx': first_commit_on_page.idx,
                               'short_id': first_commit_on_page.short_id})
 
         response.mustcontain(commit_span_template % (
             first_commit_on_page.idx, first_commit_on_page.short_id)
         )
 
         last_commit_on_page = repo.get_commit(commit_idx=last_idx)
         response.mustcontain(
             input_template % {'raw_id': last_commit_on_page.raw_id,
                               'idx': last_commit_on_page.idx,
                               'short_id': last_commit_on_page.short_id})
         response.mustcontain(commit_span_template % (
             last_commit_on_page.idx, last_commit_on_page.short_id)
         )
 
         first_commit_of_next_page = repo.get_commit(commit_idx=last_idx - 1)
         first_span_of_next_page = commit_span_template % (
             first_commit_of_next_page.idx, first_commit_of_next_page.short_id)
         assert first_span_of_next_page not in response
 
     @pytest.mark.parametrize('test_path', [
         'vcs/exceptions.py',
         '/vcs/exceptions.py',
         '//vcs/exceptions.py'
     ])
     def test_commits_with_filenode(self, backend, test_path):
         self.log_user()
         response = self.app.get(
             route_path('repo_commits_file', repo_name=backend.repo_name,
                        commit_id='tip', f_path=test_path),
             )
 
         # history commits messages
         response.mustcontain('Added exceptions module, this time for real')
         response.mustcontain('Added not implemented hg backend test case')
         response.mustcontain('Added BaseChangeset class')
 
     def test_commits_with_filenode_that_is_dirnode(self, backend):
         self.log_user()
         self.app.get(
             route_path('repo_commits_file', repo_name=backend.repo_name,
                        commit_id='tip', f_path='/tests'),
             status=302)
 
     def test_commits_with_filenode_not_existing(self, backend):
         self.log_user()
         self.app.get(
             route_path('repo_commits_file', repo_name=backend.repo_name,
                        commit_id='tip', f_path='wrong_path'),
             status=302)

rhodecode/apps/repository/tests/test_repo_commits.py

@@ -1,327 +1,327 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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.apps.repository.tests.test_repo_compare import ComparePage
 from rhodecode.lib.helpers import _shorten_commit_id
 
 
 def route_path(name, params=None, **kwargs):
     import urllib.request, urllib.parse, urllib.error
 
     base_url = {
         'repo_commit': '/{repo_name}/changeset/{commit_id}',
         'repo_commit_children': '/{repo_name}/changeset_children/{commit_id}',
         'repo_commit_parents': '/{repo_name}/changeset_parents/{commit_id}',
         'repo_commit_raw': '/{repo_name}/changeset-diff/{commit_id}',
         'repo_commit_patch': '/{repo_name}/changeset-patch/{commit_id}',
         'repo_commit_download': '/{repo_name}/changeset-download/{commit_id}',
         'repo_commit_data': '/{repo_name}/changeset-data/{commit_id}',
         'repo_compare': '/{repo_name}/compare/{source_ref_type}@{source_ref}...{target_ref_type}@{target_ref}',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
     return base_url
 
 
 @pytest.mark.usefixtures("app")
 class TestRepoCommitView(object):
 
     def test_show_commit(self, backend):
         commit_id = self.commit_id[backend.alias]
         response = self.app.get(route_path(
             'repo_commit', repo_name=backend.repo_name, commit_id=commit_id))
         response.mustcontain('Added a symlink')
         response.mustcontain(commit_id)
         response.mustcontain('No newline at end of file')
 
     def test_show_raw(self, backend):
         commit_id = self.commit_id[backend.alias]
         response = self.app.get(route_path(
             'repo_commit_raw',
             repo_name=backend.repo_name, commit_id=commit_id))
-        assert response.body == self.diffs[backend.alias]
+        assert response.text == self.diffs[backend.alias]
 
     def test_show_raw_patch(self, backend):
         response = self.app.get(route_path(
             'repo_commit_patch', repo_name=backend.repo_name,
             commit_id=self.commit_id[backend.alias]))
-        assert response.body == self.patches[backend.alias]
+        assert response.text == self.patches[backend.alias]
 
     def test_commit_download(self, backend):
         response = self.app.get(route_path(
             'repo_commit_download',
             repo_name=backend.repo_name,
             commit_id=self.commit_id[backend.alias]))
-        assert response.body == self.diffs[backend.alias]
+        assert response.text == self.diffs[backend.alias]
 
     def test_single_commit_page_different_ops(self, backend):
         commit_id = {
             'hg': '603d6c72c46d953420c89d36372f08d9f305f5dd',
             'git': '03fa803d7e9fb14daa9a3089e0d1494eda75d986',
             'svn': '337',
         }
         diff_stat = {
             'hg': (21, 943, 288),
             'git': (20, 941, 286),
             'svn': (21, 943, 288),
         }
 
         commit_id = commit_id[backend.alias]
         response = self.app.get(route_path(
             'repo_commit',
             repo_name=backend.repo_name, commit_id=commit_id))
 
         response.mustcontain(_shorten_commit_id(commit_id))
 
         compare_page = ComparePage(response)
         file_changes = diff_stat[backend.alias]
         compare_page.contains_change_summary(*file_changes)
 
         # files op files
         response.mustcontain('File not present at commit: %s' %
                              _shorten_commit_id(commit_id))
 
         # svn uses a different filename
         if backend.alias == 'svn':
             response.mustcontain('new file 10644')
         else:
             response.mustcontain('new file 100644')
         response.mustcontain('Changed theme to ADC theme')  # commit msg
 
         self._check_new_diff_menus(response, right_menu=True)
 
     def test_commit_range_page_different_ops(self, backend):
         commit_id_range = {
             'hg': (
                 '25d7e49c18b159446cadfa506a5cf8ad1cb04067',
                 '603d6c72c46d953420c89d36372f08d9f305f5dd'),
             'git': (
                 '6fc9270775aaf5544c1deb014f4ddd60c952fcbb',
                 '03fa803d7e9fb14daa9a3089e0d1494eda75d986'),
             'svn': (
                 '335',
                 '337'),
         }
         commit_ids = commit_id_range[backend.alias]
         commit_id = '%s...%s' % (commit_ids[0], commit_ids[1])
         response = self.app.get(route_path(
             'repo_commit',
             repo_name=backend.repo_name, commit_id=commit_id))
 
         response.mustcontain(_shorten_commit_id(commit_ids[0]))
         response.mustcontain(_shorten_commit_id(commit_ids[1]))
 
         compare_page = ComparePage(response)
 
         # svn is special
         if backend.alias == 'svn':
             response.mustcontain('new file 10644')
             for file_changes in [(1, 5, 1), (12, 236, 22), (21, 943, 288)]:
                 compare_page.contains_change_summary(*file_changes)
         elif backend.alias == 'git':
             response.mustcontain('new file 100644')
             for file_changes in [(12, 222, 20), (20, 941, 286)]:
                 compare_page.contains_change_summary(*file_changes)
         else:
             response.mustcontain('new file 100644')
             for file_changes in [(12, 222, 20), (21, 943, 288)]:
                 compare_page.contains_change_summary(*file_changes)
 
         # files op files
         response.mustcontain('File not present at commit: %s' % _shorten_commit_id(commit_ids[1]))
         response.mustcontain('Added docstrings to vcs.cli')  # commit msg
         response.mustcontain('Changed theme to ADC theme')  # commit msg
 
         self._check_new_diff_menus(response)
 
     def test_combined_compare_commit_page_different_ops(self, backend):
         commit_id_range = {
             'hg': (
                 '4fdd71e9427417b2e904e0464c634fdee85ec5a7',
                 '603d6c72c46d953420c89d36372f08d9f305f5dd'),
             'git': (
                 'f5fbf9cfd5f1f1be146f6d3b38bcd791a7480c13',
                 '03fa803d7e9fb14daa9a3089e0d1494eda75d986'),
             'svn': (
                 '335',
                 '337'),
         }
         commit_ids = commit_id_range[backend.alias]
         response = self.app.get(route_path(
             'repo_compare',
             repo_name=backend.repo_name,
             source_ref_type='rev', source_ref=commit_ids[0],
             target_ref_type='rev', target_ref=commit_ids[1], ))
 
         response.mustcontain(_shorten_commit_id(commit_ids[0]))
         response.mustcontain(_shorten_commit_id(commit_ids[1]))
 
         # files op files
         response.mustcontain('File not present at commit: %s' %
                              _shorten_commit_id(commit_ids[1]))
 
         compare_page = ComparePage(response)
 
         # svn is special
         if backend.alias == 'svn':
             response.mustcontain('new file 10644')
             file_changes = (32, 1179, 310)
             compare_page.contains_change_summary(*file_changes)
         elif backend.alias == 'git':
             response.mustcontain('new file 100644')
             file_changes = (31, 1163, 306)
             compare_page.contains_change_summary(*file_changes)
         else:
             response.mustcontain('new file 100644')
             file_changes = (32, 1165, 308)
             compare_page.contains_change_summary(*file_changes)
 
         response.mustcontain('Added docstrings to vcs.cli')  # commit msg
         response.mustcontain('Changed theme to ADC theme')  # commit msg
 
         self._check_new_diff_menus(response)
 
     def test_changeset_range(self, backend):
         self._check_changeset_range(
             backend, self.commit_id_range, self.commit_id_range_result)
 
     def test_changeset_range_with_initial_commit(self, backend):
         commit_id_range = {
             'hg': (
                 'b986218ba1c9b0d6a259fac9b050b1724ed8e545'
                 '...6cba7170863a2411822803fa77a0a264f1310b35'),
             'git': (
                 'c1214f7e79e02fc37156ff215cd71275450cffc3'
                 '...fa6600f6848800641328adbf7811fd2372c02ab2'),
             'svn': '1...3',
         }
         commit_id_range_result = {
             'hg': ['b986218ba1c9', '3d8f361e72ab', '6cba7170863a'],
             'git': ['c1214f7e79e0', '38b5fe81f109', 'fa6600f68488'],
             'svn': ['1', '2', '3'],
         }
         self._check_changeset_range(
             backend, commit_id_range, commit_id_range_result)
 
     def _check_changeset_range(
             self, backend, commit_id_ranges, commit_id_range_result):
         response = self.app.get(
             route_path('repo_commit',
                        repo_name=backend.repo_name,
                        commit_id=commit_id_ranges[backend.alias]))
 
         expected_result = commit_id_range_result[backend.alias]
         response.mustcontain('{} commits'.format(len(expected_result)))
         for commit_id in expected_result:
             response.mustcontain(commit_id)
 
     commit_id = {
         'hg': '2062ec7beeeaf9f44a1c25c41479565040b930b2',
         'svn': '393',
         'git': 'fd627b9e0dd80b47be81af07c4a98518244ed2f7',
     }
 
     commit_id_range = {
         'hg': (
             'a53d9201d4bc278910d416d94941b7ea007ecd52'
             '...2062ec7beeeaf9f44a1c25c41479565040b930b2'),
         'git': (
             '7ab37bc680b4aa72c34d07b230c866c28e9fc204'
             '...fd627b9e0dd80b47be81af07c4a98518244ed2f7'),
         'svn': '391...393',
     }
 
     commit_id_range_result = {
         'hg': ['a53d9201d4bc', '96507bd11ecc', '2062ec7beeea'],
         'git': ['7ab37bc680b4', '5f2c6ee19592', 'fd627b9e0dd8'],
         'svn': ['391', '392', '393'],
     }
 
     diffs = {
         'hg': r"""diff --git a/README b/README
 new file mode 120000
 --- /dev/null
 +++ b/README
 @@ -0,0 +1,1 @@
 +README.rst
 \ No newline at end of file
 """,
         'git': r"""diff --git a/README b/README
 new file mode 120000
 index 0000000..92cacd2
 --- /dev/null
 +++ b/README
 @@ -0,0 +1 @@
 +README.rst
 \ No newline at end of file
 """,
         'svn': """Index: README
 ===================================================================
 diff --git a/README b/README
 new file mode 10644
 --- /dev/null\t(revision 0)
 +++ b/README\t(revision 393)
 @@ -0,0 +1 @@
 +link README.rst
 \\ No newline at end of file
 """,
     }
 
     patches = {
         'hg': r"""# HG changeset patch
 # User Marcin Kuzminski <[e-mail]>
 # Date 2014-01-07 12:21:40
 # Node ID 2062ec7beeeaf9f44a1c25c41479565040b930b2
 # Parent  96507bd11ecc815ebc6270fdf6db110928c09c1e
 
 Added a symlink
 
 """ + diffs['hg'],
         'git': r"""From fd627b9e0dd80b47be81af07c4a98518244ed2f7 2014-01-07 12:22:20
 From: Marcin Kuzminski <[e-mail]>
 Date: 2014-01-07 12:22:20
 Subject: [PATCH] Added a symlink
 
 ---
 
 """ + diffs['git'],
         'svn': r"""# SVN changeset patch
 # User marcin
 # Date 2014-09-02 12:25:22.071142
 # Revision 393
 
 Added a symlink
 
 """ + diffs['svn'],
     }
 
     def _check_new_diff_menus(self, response, right_menu=False,):
         # individual file diff menus
         for elem in ['Show file before', 'Show file after']:
             response.mustcontain(elem)
 
         # right pane diff menus
         if right_menu:
             for elem in ['Hide whitespace changes', 'Toggle wide diff',
                          'Show full context diff']:
                 response.mustcontain(elem)

rhodecode/apps/repository/tests/test_repo_compare.py

@@ -1,672 +1,672 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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 mock
 import pytest
 import lxml.html
 
 from rhodecode.lib.vcs.exceptions import RepositoryRequirementError
 from rhodecode.tests import assert_session_flash
 from rhodecode.tests.utils import AssertResponse, commit_change
 
 
 def route_path(name, params=None, **kwargs):
     import urllib.request, urllib.parse, urllib.error
 
     base_url = {
         'repo_compare_select': '/{repo_name}/compare',
         'repo_compare': '/{repo_name}/compare/{source_ref_type}@{source_ref}...{target_ref_type}@{target_ref}',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
     return base_url
 
 
 @pytest.mark.usefixtures("autologin_user", "app")
 class TestCompareView(object):
 
     def test_compare_index_is_reached_at_least_once(self, backend):
         repo = backend.repo
         self.app.get(
             route_path('repo_compare_select', repo_name=repo.repo_name))
 
     @pytest.mark.xfail_backends("svn", reason="Requires pull")
     def test_compare_remote_with_different_commit_indexes(self, backend):
         # Preparing the following repository structure:
         #
         # Origin repository has two commits:
         #
         #    0    1
         #    A -- D
         #
         # The fork of it has a few more commits and "D" has a commit index
         # which does not exist in origin.
         #
         #    0    1    2    3    4
         #    A --   --   -- D -- E
         #      \- B -- C
         #
 
         fork = backend.create_repo()
 
         # prepare fork
         commit0 = commit_change(
             fork.repo_name, filename='file1', content='A',
             message='A', vcs_type=backend.alias, parent=None, newfile=True)
 
         commit1 = commit_change(
             fork.repo_name, filename='file1', content='B',
             message='B, child of A', vcs_type=backend.alias, parent=commit0)
 
         commit_change(  # commit 2
             fork.repo_name, filename='file1', content='C',
             message='C, child of B', vcs_type=backend.alias, parent=commit1)
 
         commit3 = commit_change(
             fork.repo_name, filename='file1', content='D',
             message='D, child of A', vcs_type=backend.alias, parent=commit0)
 
         commit4 = commit_change(
             fork.repo_name, filename='file1', content='E',
             message='E, child of D', vcs_type=backend.alias, parent=commit3)
 
         # prepare origin repository, taking just the history up to D
         origin = backend.create_repo()
 
         origin_repo = origin.scm_instance(cache=False)
         origin_repo.config.clear_section('hooks')
         origin_repo.pull(fork.repo_full_path, commit_ids=[commit3.raw_id])
         origin_repo = origin.scm_instance(cache=False)  # cache rebuild
 
         # Verify test fixture setup
         # This does not work for git
         if backend.alias != 'git':
             assert 5 == len(fork.scm_instance().commit_ids)
             assert 2 == len(origin_repo.commit_ids)
 
         # Comparing the revisions
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=origin.repo_name,
                        source_ref_type="rev", source_ref=commit3.raw_id,
                        target_ref_type="rev", target_ref=commit4.raw_id,
                        params=dict(merge='1', target_repo=fork.repo_name)
                        ))
 
         compare_page = ComparePage(response)
         compare_page.contains_commits([commit4])
 
     @pytest.mark.xfail_backends("svn", reason="Depends on branch support")
     def test_compare_forks_on_branch_extra_commits(self, backend):
         repo1 = backend.create_repo()
 
         # commit something !
         commit0 = commit_change(
             repo1.repo_name, filename='file1', content='line1\n',
             message='commit1', vcs_type=backend.alias, parent=None,
             newfile=True)
 
         # fork this repo
         repo2 = backend.create_fork()
 
         # add two extra commit into fork
         commit1 = commit_change(
             repo2.repo_name, filename='file1', content='line1\nline2\n',
             message='commit2', vcs_type=backend.alias, parent=commit0)
 
         commit2 = commit_change(
             repo2.repo_name, filename='file1', content='line1\nline2\nline3\n',
             message='commit3', vcs_type=backend.alias, parent=commit1)
 
         commit_id1 = repo1.scm_instance().DEFAULT_BRANCH_NAME
         commit_id2 = repo2.scm_instance().DEFAULT_BRANCH_NAME
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo1.repo_name,
                        source_ref_type="branch", source_ref=commit_id2,
                        target_ref_type="branch", target_ref=commit_id1,
                        params=dict(merge='1', target_repo=repo2.repo_name)
                        ))
 
         response.mustcontain('%s@%s' % (repo1.repo_name, commit_id2))
         response.mustcontain('%s@%s' % (repo2.repo_name, commit_id1))
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 2, 0)
         compare_page.contains_commits([commit1, commit2])
 
         anchor = 'a_c-{}-826e8142e6ba'.format(commit0.short_id)
         compare_page.contains_file_links_and_anchors([('file1', anchor), ])
 
         # Swap is removed when comparing branches since it's a PR feature and
         # it is then a preview mode
         compare_page.swap_is_hidden()
         compare_page.target_source_are_disabled()
 
     @pytest.mark.xfail_backends("svn", reason="Depends on branch support")
     def test_compare_forks_on_branch_extra_commits_origin_has_incomming(self, backend):
         repo1 = backend.create_repo()
 
         # commit something !
         commit0 = commit_change(
             repo1.repo_name, filename='file1', content='line1\n',
             message='commit1', vcs_type=backend.alias, parent=None,
             newfile=True)
 
         # fork this repo
         repo2 = backend.create_fork()
 
         # now commit something to origin repo
         commit_change(
             repo1.repo_name, filename='file2', content='line1file2\n',
             message='commit2', vcs_type=backend.alias, parent=commit0,
             newfile=True)
 
         # add two extra commit into fork
         commit1 = commit_change(
             repo2.repo_name, filename='file1', content='line1\nline2\n',
             message='commit2', vcs_type=backend.alias, parent=commit0)
 
         commit2 = commit_change(
             repo2.repo_name, filename='file1', content='line1\nline2\nline3\n',
             message='commit3', vcs_type=backend.alias, parent=commit1)
 
         commit_id1 = repo1.scm_instance().DEFAULT_BRANCH_NAME
         commit_id2 = repo2.scm_instance().DEFAULT_BRANCH_NAME
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo1.repo_name,
                        source_ref_type="branch", source_ref=commit_id2,
                        target_ref_type="branch", target_ref=commit_id1,
                        params=dict(merge='1', target_repo=repo2.repo_name),
                        ))
 
         response.mustcontain('%s@%s' % (repo1.repo_name, commit_id2))
         response.mustcontain('%s@%s' % (repo2.repo_name, commit_id1))
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 2, 0)
         compare_page.contains_commits([commit1, commit2])
         anchor = 'a_c-{}-826e8142e6ba'.format(commit0.short_id)
         compare_page.contains_file_links_and_anchors([('file1', anchor), ])
 
         # Swap is removed when comparing branches since it's a PR feature and
         # it is then a preview mode
         compare_page.swap_is_hidden()
         compare_page.target_source_are_disabled()
 
     @pytest.mark.xfail_backends("svn")
     # TODO(marcink): no svn support for compare two seperate repos
     def test_compare_of_unrelated_forks(self, backend):
         orig = backend.create_repo(number_of_commits=1)
         fork = backend.create_repo(number_of_commits=1)
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=orig.repo_name,
                        source_ref_type="rev", source_ref="tip",
                        target_ref_type="rev", target_ref="tip",
                        params=dict(merge='1', target_repo=fork.repo_name),
                        ),
             status=302)
         response = response.follow()
         response.mustcontain("Repositories unrelated.")
 
     @pytest.mark.xfail_backends("svn")
     def test_compare_cherry_pick_commits_from_bottom(self, backend):
 
         # repo1:
         #     commit0:
         #     commit1:
         # repo1-fork- in which we will cherry pick bottom commits
         #     commit0:
         #     commit1:
         #     commit2: x
         #     commit3: x
         #     commit4: x
         #     commit5:
         # make repo1, and commit1+commit2
 
         repo1 = backend.create_repo()
 
         # commit something !
         commit0 = commit_change(
             repo1.repo_name, filename='file1', content='line1\n',
             message='commit1', vcs_type=backend.alias, parent=None,
             newfile=True)
         commit1 = commit_change(
             repo1.repo_name, filename='file1', content='line1\nline2\n',
             message='commit2', vcs_type=backend.alias, parent=commit0)
 
         # fork this repo
         repo2 = backend.create_fork()
 
         # now make commit3-6
         commit2 = commit_change(
             repo1.repo_name, filename='file1', content='line1\nline2\nline3\n',
             message='commit3', vcs_type=backend.alias, parent=commit1)
         commit3 = commit_change(
             repo1.repo_name, filename='file1',
             content='line1\nline2\nline3\nline4\n', message='commit4',
             vcs_type=backend.alias, parent=commit2)
         commit4 = commit_change(
             repo1.repo_name, filename='file1',
             content='line1\nline2\nline3\nline4\nline5\n', message='commit5',
             vcs_type=backend.alias, parent=commit3)
         commit_change(  # commit 5
             repo1.repo_name, filename='file1',
             content='line1\nline2\nline3\nline4\nline5\nline6\n',
             message='commit6', vcs_type=backend.alias, parent=commit4)
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo2.repo_name,
                        # parent of commit2, in target repo2
                        source_ref_type="rev", source_ref=commit1.raw_id,
                        target_ref_type="rev", target_ref=commit4.raw_id,
                        params=dict(merge='1', target_repo=repo1.repo_name),
                        ))
         response.mustcontain('%s@%s' % (repo2.repo_name, commit1.short_id))
         response.mustcontain('%s@%s' % (repo1.repo_name, commit4.short_id))
 
         # files
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 3, 0)
         compare_page.contains_commits([commit2, commit3, commit4])
         anchor = 'a_c-{}-826e8142e6ba'.format(commit1.short_id)
         compare_page.contains_file_links_and_anchors([('file1', anchor),])
 
     @pytest.mark.xfail_backends("svn")
     def test_compare_cherry_pick_commits_from_top(self, backend):
         # repo1:
         #     commit0:
         #     commit1:
         # repo1-fork- in which we will cherry pick bottom commits
         #     commit0:
         #     commit1:
         #     commit2:
         #     commit3: x
         #     commit4: x
         #     commit5: x
 
         # make repo1, and commit1+commit2
         repo1 = backend.create_repo()
 
         # commit something !
         commit0 = commit_change(
             repo1.repo_name, filename='file1', content='line1\n',
             message='commit1', vcs_type=backend.alias, parent=None,
             newfile=True)
         commit1 = commit_change(
             repo1.repo_name, filename='file1', content='line1\nline2\n',
             message='commit2', vcs_type=backend.alias, parent=commit0)
 
         # fork this repo
         backend.create_fork()
 
         # now make commit3-6
         commit2 = commit_change(
             repo1.repo_name, filename='file1', content='line1\nline2\nline3\n',
             message='commit3', vcs_type=backend.alias, parent=commit1)
         commit3 = commit_change(
             repo1.repo_name, filename='file1',
             content='line1\nline2\nline3\nline4\n', message='commit4',
             vcs_type=backend.alias, parent=commit2)
         commit4 = commit_change(
             repo1.repo_name, filename='file1',
             content='line1\nline2\nline3\nline4\nline5\n', message='commit5',
             vcs_type=backend.alias, parent=commit3)
         commit5 = commit_change(
             repo1.repo_name, filename='file1',
             content='line1\nline2\nline3\nline4\nline5\nline6\n',
             message='commit6', vcs_type=backend.alias, parent=commit4)
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo1.repo_name,
                        # parent of commit3, not in source repo2
                        source_ref_type="rev", source_ref=commit2.raw_id,
                        target_ref_type="rev", target_ref=commit5.raw_id,
                        params=dict(merge='1'),))
 
         response.mustcontain('%s@%s' % (repo1.repo_name, commit2.short_id))
         response.mustcontain('%s@%s' % (repo1.repo_name, commit5.short_id))
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 3, 0)
         compare_page.contains_commits([commit3, commit4, commit5])
 
         # files
         anchor = 'a_c-{}-826e8142e6ba'.format(commit2.short_id)
         compare_page.contains_file_links_and_anchors([('file1', anchor),])
 
     @pytest.mark.xfail_backends("svn")
     def test_compare_remote_branches(self, backend):
         repo1 = backend.repo
         repo2 = backend.create_fork()
 
         commit_id1 = repo1.get_commit(commit_idx=3).raw_id
         commit_id1_short = repo1.get_commit(commit_idx=3).short_id
         commit_id2 = repo1.get_commit(commit_idx=6).raw_id
         commit_id2_short = repo1.get_commit(commit_idx=6).short_id
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo1.repo_name,
                        source_ref_type="rev", source_ref=commit_id1,
                        target_ref_type="rev", target_ref=commit_id2,
                        params=dict(merge='1', target_repo=repo2.repo_name),
                        ))
 
         response.mustcontain('%s@%s' % (repo1.repo_name, commit_id1))
         response.mustcontain('%s@%s' % (repo2.repo_name, commit_id2))
 
         compare_page = ComparePage(response)
 
         # outgoing commits between those commits
         compare_page.contains_commits(
             [repo2.get_commit(commit_idx=x) for x in [4, 5, 6]])
 
         # files
         compare_page.contains_file_links_and_anchors([
             ('vcs/backends/hg.py', 'a_c-{}-9c390eb52cd6'.format(commit_id2_short)),
             ('vcs/backends/__init__.py', 'a_c-{}-41b41c1f2796'.format(commit_id1_short)),
             ('vcs/backends/base.py', 'a_c-{}-2f574d260608'.format(commit_id1_short)),
         ])
 
     @pytest.mark.xfail_backends("svn")
     def test_source_repo_new_commits_after_forking_simple_diff(self, backend):
         repo1 = backend.create_repo()
         r1_name = repo1.repo_name
 
         commit0 = commit_change(
             repo=r1_name, filename='file1',
             content='line1', message='commit1', vcs_type=backend.alias,
             newfile=True)
         assert repo1.scm_instance().commit_ids == [commit0.raw_id]
 
         # fork the repo1
         repo2 = backend.create_fork()
         assert repo2.scm_instance().commit_ids == [commit0.raw_id]
 
         self.r2_id = repo2.repo_id
         r2_name = repo2.repo_name
 
         commit1 = commit_change(
             repo=r2_name, filename='file1-fork',
             content='file1-line1-from-fork', message='commit1-fork',
             vcs_type=backend.alias, parent=repo2.scm_instance()[-1],
             newfile=True)
 
         commit2 = commit_change(
             repo=r2_name, filename='file2-fork',
             content='file2-line1-from-fork', message='commit2-fork',
             vcs_type=backend.alias, parent=commit1,
             newfile=True)
 
         commit_change(  # commit 3
             repo=r2_name, filename='file3-fork',
             content='file3-line1-from-fork', message='commit3-fork',
             vcs_type=backend.alias, parent=commit2, newfile=True)
 
         # compare !
         commit_id1 = repo1.scm_instance().DEFAULT_BRANCH_NAME
         commit_id2 = repo2.scm_instance().DEFAULT_BRANCH_NAME
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=r2_name,
                        source_ref_type="branch", source_ref=commit_id1,
                        target_ref_type="branch", target_ref=commit_id2,
                        params=dict(merge='1', target_repo=r1_name),
                        ))
 
         response.mustcontain('%s@%s' % (r2_name, commit_id1))
         response.mustcontain('%s@%s' % (r1_name, commit_id2))
         response.mustcontain('No files')
         response.mustcontain('No commits in this compare')
 
         commit0 = commit_change(
             repo=r1_name, filename='file2',
             content='line1-added-after-fork', message='commit2-parent',
             vcs_type=backend.alias, parent=None, newfile=True)
 
         # compare !
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=r2_name,
                        source_ref_type="branch", source_ref=commit_id1,
                        target_ref_type="branch", target_ref=commit_id2,
                        params=dict(merge='1', target_repo=r1_name),
                        ))
 
         response.mustcontain('%s@%s' % (r2_name, commit_id1))
         response.mustcontain('%s@%s' % (r1_name, commit_id2))
 
         response.mustcontain("""commit2-parent""")
         response.mustcontain("""line1-added-after-fork""")
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 1, 0)
 
     @pytest.mark.xfail_backends("svn")
     def test_compare_commits(self, backend, xhr_header):
         commit0 = backend.repo.get_commit(commit_idx=0)
         commit1 = backend.repo.get_commit(commit_idx=1)
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=backend.repo_name,
                        source_ref_type="rev", source_ref=commit0.raw_id,
                        target_ref_type="rev", target_ref=commit1.raw_id,
                        params=dict(merge='1')
                        ),
             extra_environ=xhr_header, )
 
         # outgoing commits between those commits
         compare_page = ComparePage(response)
         compare_page.contains_commits(commits=[commit1])
 
     def test_errors_when_comparing_unknown_source_repo(self, backend):
         repo = backend.repo
         badrepo = 'badrepo'
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=badrepo,
                        source_ref_type="rev", source_ref='tip',
                        target_ref_type="rev", target_ref='tip',
                        params=dict(merge='1', target_repo=repo.repo_name)
                        ),
             status=404)
 
     def test_errors_when_comparing_unknown_target_repo(self, backend):
         repo = backend.repo
         badrepo = 'badrepo'
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=repo.repo_name,
                        source_ref_type="rev", source_ref='tip',
                        target_ref_type="rev", target_ref='tip',
                        params=dict(merge='1', target_repo=badrepo),
                        ),
             status=302)
         redirected = response.follow()
         redirected.mustcontain(
             'Could not find the target repo: `{}`'.format(badrepo))
 
     def test_compare_not_in_preview_mode(self, backend_stub):
         commit0 = backend_stub.repo.get_commit(commit_idx=0)
         commit1 = backend_stub.repo.get_commit(commit_idx=1)
 
         response = self.app.get(
             route_path('repo_compare',
                        repo_name=backend_stub.repo_name,
                        source_ref_type="rev", source_ref=commit0.raw_id,
                        target_ref_type="rev", target_ref=commit1.raw_id,
                        ))
 
         # outgoing commits between those commits
         compare_page = ComparePage(response)
         compare_page.swap_is_visible()
         compare_page.target_source_are_enabled()
 
     def test_compare_of_fork_with_largefiles(self, backend_hg, settings_util):
         orig = backend_hg.create_repo(number_of_commits=1)
         fork = backend_hg.create_fork()
 
         settings_util.create_repo_rhodecode_ui(
             orig, 'extensions', value='', key='largefiles', active=False)
         settings_util.create_repo_rhodecode_ui(
             fork, 'extensions', value='', key='largefiles', active=True)
 
         compare_module = ('rhodecode.lib.vcs.backends.hg.repository.'
                           'MercurialRepository.compare')
         with mock.patch(compare_module) as compare_mock:
             compare_mock.side_effect = RepositoryRequirementError()
 
             response = self.app.get(
                 route_path('repo_compare',
                            repo_name=orig.repo_name,
                            source_ref_type="rev", source_ref="tip",
                            target_ref_type="rev", target_ref="tip",
                            params=dict(merge='1', target_repo=fork.repo_name),
                            ),
                 status=302)
 
             assert_session_flash(
                 response,
                 'Could not compare repos with different large file settings')
 
 
 @pytest.mark.usefixtures("autologin_user")
 class TestCompareControllerSvn(object):
 
     def test_supports_references_with_path(self, app, backend_svn):
         repo = backend_svn['svn-simple-layout']
         commit_id = repo.get_commit(commit_idx=-1).raw_id
         response = app.get(
             route_path('repo_compare',
                        repo_name=repo.repo_name,
                        source_ref_type="tag",
                        source_ref="%s@%s" % ('tags/v0.1', commit_id),
                        target_ref_type="tag",
                        target_ref="%s@%s" % ('tags/v0.2', commit_id),
                        params=dict(merge='1'),
                        ),
             status=200)
 
         # Expecting no commits, since both paths are at the same revision
         response.mustcontain('No commits in this compare')
 
         # Should find only one file changed when comparing those two tags
         response.mustcontain('example.py')
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 5, 1)
 
     def test_shows_commits_if_different_ids(self, app, backend_svn):
         repo = backend_svn['svn-simple-layout']
         source_id = repo.get_commit(commit_idx=-6).raw_id
         target_id = repo.get_commit(commit_idx=-1).raw_id
         response = app.get(
             route_path('repo_compare',
                        repo_name=repo.repo_name,
                        source_ref_type="tag",
                        source_ref="%s@%s" % ('tags/v0.1', source_id),
                        target_ref_type="tag",
                        target_ref="%s@%s" % ('tags/v0.2', target_id),
                        params=dict(merge='1')
                        ),
             status=200)
 
         # It should show commits
-        assert 'No commits in this compare' not in response.body
+        assert 'No commits in this compare' not in response.text
 
         # Should find only one file changed when comparing those two tags
         response.mustcontain('example.py')
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(1, 5, 1)
 
 
 class ComparePage(AssertResponse):
     """
     Abstracts the page template from the tests
     """
 
     def contains_file_links_and_anchors(self, files):
         doc = lxml.html.fromstring(self.response.body)
         for filename, file_id in files:
             self.contains_one_anchor(file_id)
             diffblock = doc.cssselect('[data-f-path="%s"]' % filename)
             assert len(diffblock) == 2
             for lnk in diffblock[0].cssselect('a'):
                 if 'permalink' in lnk.text:
                     assert '#{}'.format(file_id) in lnk.attrib['href']
                     break
             else:
                 pytest.fail('Unable to find permalink')
 
     def contains_change_summary(self, files_changed, inserted, deleted):
         template = (
             '{files_changed} file{plural} changed: '
             '<span class="op-added">{inserted} inserted</span>, <span class="op-deleted">{deleted} deleted</span>')
         self.response.mustcontain(template.format(
             files_changed=files_changed,
             plural="s" if files_changed > 1 else "",
             inserted=inserted,
             deleted=deleted))
 
     def contains_commits(self, commits, ancestors=None):
         response = self.response
 
         for commit in commits:
             # Expecting to see the commit message in an element which
             # has the ID "c-{commit.raw_id}"
             self.element_contains('#c-' + commit.raw_id, commit.message)
             self.contains_one_link(
                 'r%s:%s' % (commit.idx, commit.short_id),
                 self._commit_url(commit))
 
         if ancestors:
             response.mustcontain('Ancestor')
             for ancestor in ancestors:
                 self.contains_one_link(
                     ancestor.short_id, self._commit_url(ancestor))
 
     def _commit_url(self, commit):
         return '/%s/changeset/%s' % (commit.repository.name, commit.raw_id)
 
     def swap_is_hidden(self):
         assert '<a id="btn-swap"' not in self.response.text
 
     def swap_is_visible(self):
         assert '<a id="btn-swap"' in self.response.text
 
     def target_source_are_disabled(self):
         response = self.response
         response.mustcontain("var enable_fields = false;")
         response.mustcontain('.select2("enable", enable_fields)')
 
     def target_source_are_enabled(self):
         response = self.response
         response.mustcontain("var enable_fields = true;")

rhodecode/apps/repository/tests/test_repo_files.py

@@ -1,1092 +1,1092 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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.apps.repository.tests.test_repo_compare import ComparePage
 from rhodecode.apps.repository.views.repo_files import RepoFilesView
 from rhodecode.lib import helpers as h
 from collections import OrderedDict
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.vcs import nodes
 
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.tests import assert_session_flash
 from rhodecode.tests.fixture import Fixture
 from rhodecode.model.db import Session
 
 fixture = Fixture()
 
 
 def get_node_history(backend_type):
     return {
         'hg': json.loads(fixture.load_resource('hg_node_history_response.json')),
         'git': json.loads(fixture.load_resource('git_node_history_response.json')),
         'svn': json.loads(fixture.load_resource('svn_node_history_response.json')),
     }[backend_type]
 
 
 def route_path(name, params=None, **kwargs):
     import urllib.request, urllib.parse, urllib.error
 
     base_url = {
         'repo_summary': '/{repo_name}',
         'repo_archivefile': '/{repo_name}/archive/{fname}',
         'repo_files_diff': '/{repo_name}/diff/{f_path}',
         'repo_files_diff_2way_redirect':  '/{repo_name}/diff-2way/{f_path}',
         'repo_files': '/{repo_name}/files/{commit_id}/{f_path}',
         'repo_files:default_path': '/{repo_name}/files/{commit_id}/',
         'repo_files:default_commit': '/{repo_name}/files',
         'repo_files:rendered': '/{repo_name}/render/{commit_id}/{f_path}',
         'repo_files:annotated': '/{repo_name}/annotate/{commit_id}/{f_path}',
         'repo_files:annotated_previous': '/{repo_name}/annotate-previous/{commit_id}/{f_path}',
         'repo_files_nodelist': '/{repo_name}/nodelist/{commit_id}/{f_path}',
         'repo_file_raw': '/{repo_name}/raw/{commit_id}/{f_path}',
         'repo_file_download': '/{repo_name}/download/{commit_id}/{f_path}',
         'repo_file_history': '/{repo_name}/history/{commit_id}/{f_path}',
         'repo_file_authors': '/{repo_name}/authors/{commit_id}/{f_path}',
         'repo_files_remove_file': '/{repo_name}/remove_file/{commit_id}/{f_path}',
         'repo_files_delete_file': '/{repo_name}/delete_file/{commit_id}/{f_path}',
         'repo_files_edit_file': '/{repo_name}/edit_file/{commit_id}/{f_path}',
         'repo_files_update_file': '/{repo_name}/update_file/{commit_id}/{f_path}',
         'repo_files_add_file': '/{repo_name}/add_file/{commit_id}/{f_path}',
         'repo_files_create_file': '/{repo_name}/create_file/{commit_id}/{f_path}',
         'repo_nodetree_full': '/{repo_name}/nodetree_full/{commit_id}/{f_path}',
         'repo_nodetree_full:default_path': '/{repo_name}/nodetree_full/{commit_id}/',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
     return base_url
 
 
 def assert_files_in_response(response, files, params):
     template = (
         'href="/%(repo_name)s/files/%(commit_id)s/%(name)s"')
     _assert_items_in_response(response, files, template, params)
 
 
 def assert_dirs_in_response(response, dirs, params):
     template = (
         'href="/%(repo_name)s/files/%(commit_id)s/%(name)s"')
     _assert_items_in_response(response, dirs, template, params)
 
 
 def _assert_items_in_response(response, items, template, params):
     for item in items:
         item_params = {'name': item}
         item_params.update(params)
         response.mustcontain(template % item_params)
 
 
 def assert_timeago_in_response(response, items, params):
     for item in items:
         response.mustcontain(h.age_component(params['date']))
 
 
 @pytest.mark.usefixtures("app")
 class TestFilesViews(object):
 
     def test_show_files(self, backend):
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'))
         commit = backend.repo.get_commit()
 
         params = {
             'repo_name': backend.repo_name,
             'commit_id': commit.raw_id,
             'date': commit.date
         }
         assert_dirs_in_response(response, ['docs', 'vcs'], params)
         files = [
             '.gitignore',
             '.hgignore',
             '.hgtags',
             # TODO: missing in Git
             # '.travis.yml',
             'MANIFEST.in',
             'README.rst',
             # TODO: File is missing in svn repository
             # 'run_test_and_report.sh',
             'setup.cfg',
             'setup.py',
             'test_and_report.sh',
             'tox.ini',
         ]
         assert_files_in_response(response, files, params)
         assert_timeago_in_response(response, files, params)
 
     def test_show_files_links_submodules_with_absolute_url(self, backend_hg):
         repo = backend_hg['subrepos']
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
         assert_response = response.assert_response()
         assert_response.contains_one_link(
             'absolute-path @ 000000000000', 'http://example.com/absolute-path')
 
     def test_show_files_links_submodules_with_absolute_url_subpaths(
             self, backend_hg):
         repo = backend_hg['subrepos']
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
         assert_response = response.assert_response()
         assert_response.contains_one_link(
             'subpaths-path @ 000000000000',
             'http://sub-base.example.com/subpaths-path')
 
     @pytest.mark.xfail_backends("svn", reason="Depends on branch support")
     def test_files_menu(self, backend):
         new_branch = "temp_branch_name"
         commits = [
             {'message': 'a'},
             {'message': 'b', 'branch': new_branch}
         ]
         backend.create_repo(commits)
         backend.repo.landing_rev = "branch:%s" % new_branch
         Session().commit()
 
         # get response based on tip and not new commit
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'))
 
         # make sure Files menu url is not tip but new commit
         landing_rev = backend.repo.landing_ref_name
         files_url = route_path('repo_files:default_path',
                                repo_name=backend.repo_name,
                                commit_id=landing_rev, params={'at': landing_rev})
 
         assert landing_rev != 'tip'
         response.mustcontain(
             '<li class="active"><a class="menulink" href="%s">' % files_url)
 
     def test_show_files_commit(self, backend):
         commit = backend.repo.get_commit(commit_idx=32)
 
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'))
 
         dirs = ['docs', 'tests']
         files = ['README.rst']
         params = {
             'repo_name': backend.repo_name,
             'commit_id': commit.raw_id,
         }
         assert_dirs_in_response(response, dirs, params)
         assert_files_in_response(response, files, params)
 
     def test_show_files_different_branch(self, backend):
         branches = dict(
             hg=(150, ['git']),
             # TODO: Git test repository does not contain other branches
             git=(633, ['master']),
             # TODO: Branch support in Subversion
             svn=(150, [])
         )
         idx, branches = branches[backend.alias]
         commit = backend.repo.get_commit(commit_idx=idx)
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'))
 
         assert_response = response.assert_response()
         for branch in branches:
             assert_response.element_contains('.tags .branchtag', branch)
 
     def test_show_files_paging(self, backend):
         repo = backend.repo
         indexes = [73, 92, 109, 1, 0]
         idx_map = [(rev, repo.get_commit(commit_idx=rev).raw_id)
                    for rev in indexes]
 
         for idx in idx_map:
             response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=idx[1], f_path='/'))
 
             response.mustcontain("""r%s:%s""" % (idx[0], idx[1][:8]))
 
     def test_file_source(self, backend):
         commit = backend.repo.get_commit(commit_idx=167)
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='vcs/nodes.py'))
 
         msgbox = """<div class="commit">%s</div>"""
         response.mustcontain(msgbox % (commit.message, ))
 
         assert_response = response.assert_response()
         if commit.branch:
             assert_response.element_contains(
                 '.tags.tags-main .branchtag', commit.branch)
         if commit.tags:
             for tag in commit.tags:
                 assert_response.element_contains('.tags.tags-main .tagtag', tag)
 
     def test_file_source_annotated(self, backend):
         response = self.app.get(
             route_path('repo_files:annotated',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py'))
         expected_commits = {
             'hg': 'r356',
             'git': 'r345',
             'svn': 'r208',
         }
         response.mustcontain(expected_commits[backend.alias])
 
     def test_file_source_authors(self, backend):
         response = self.app.get(
             route_path('repo_file_authors',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py'))
         expected_authors = {
             'hg': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'git': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'svn': ('marcin', 'lukasz'),
         }
 
         for author in expected_authors[backend.alias]:
             response.mustcontain(author)
 
     def test_file_source_authors_with_annotation(self, backend):
         response = self.app.get(
             route_path('repo_file_authors',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py',
                        params=dict(annotate=1)))
         expected_authors = {
             'hg': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'git': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'svn': ('marcin', 'lukasz'),
         }
 
         for author in expected_authors[backend.alias]:
             response.mustcontain(author)
 
     def test_file_source_history(self, backend, xhr_header):
         response = self.app.get(
             route_path('repo_file_history',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py'),
             extra_environ=xhr_header)
         assert get_node_history(backend.alias) == json.loads(response.body)
 
     def test_file_source_history_svn(self, backend_svn, xhr_header):
         simple_repo = backend_svn['svn-simple-layout']
         response = self.app.get(
             route_path('repo_file_history',
                        repo_name=simple_repo.repo_name,
                        commit_id='tip', f_path='trunk/example.py'),
             extra_environ=xhr_header)
 
         expected_data = json.loads(
             fixture.load_resource('svn_node_history_branches.json'))
 
         assert expected_data == response.json
 
     def test_file_source_history_with_annotation(self, backend, xhr_header):
         response = self.app.get(
             route_path('repo_file_history',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py',
                        params=dict(annotate=1)),
 
             extra_environ=xhr_header)
         assert get_node_history(backend.alias) == json.loads(response.body)
 
     def test_tree_search_top_level(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'),
             extra_environ=xhr_header)
         assert 'nodes' in response.json
         assert {'name': 'docs', 'type': 'dir'} in response.json['nodes']
 
     def test_tree_search_missing_xhr(self, backend):
         self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'),
             status=404)
 
     def test_tree_search_at_path(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/docs'),
             extra_environ=xhr_header)
         assert 'nodes' in response.json
         nodes = response.json['nodes']
         assert {'name': 'docs/api', 'type': 'dir'} in nodes
         assert {'name': 'docs/index.rst', 'type': 'file'} in nodes
 
     def test_tree_search_at_path_2nd_level(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/docs/api'),
             extra_environ=xhr_header)
         assert 'nodes' in response.json
         nodes = response.json['nodes']
         assert {'name': 'docs/api/index.rst', 'type': 'file'} in nodes
 
     def test_tree_search_at_path_missing_xhr(self, backend):
         self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/docs'),
             status=404)
 
     def test_nodetree(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'),
             extra_environ=xhr_header)
 
         assert_response = response.assert_response()
 
         for attr in ['data-commit-id', 'data-date', 'data-author']:
             elements = assert_response.get_elements('[{}]'.format(attr))
             assert len(elements) > 1
 
             for element in elements:
                 assert element.get(attr)
 
     def test_nodetree_if_file(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='README.rst'),
             extra_environ=xhr_header)
-        assert response.body == ''
+        assert response.text == ''
 
     def test_nodetree_wrong_path(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/dont-exist'),
             extra_environ=xhr_header)
 
         err = 'error: There is no file nor ' \
               'directory at the given path'
-        assert err in response.body
+        assert err in response.text
 
     def test_nodetree_missing_xhr(self, backend):
         self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'),
             status=404)
 
 
 @pytest.mark.usefixtures("app", "autologin_user")
 class TestRawFileHandling(object):
 
     def test_download_file(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_file_download',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='vcs/nodes.py'),)
 
         assert response.content_disposition == 'attachment; filename="nodes.py"; filename*=UTF-8\'\'nodes.py'
         assert response.content_type == "text/x-python"
 
     def test_download_file_wrong_cs(self, backend):
         raw_id = u'ERRORce30c96924232dffcd24178a07ffeb5dfc'
 
         response = self.app.get(
             route_path('repo_file_download',
                        repo_name=backend.repo_name,
                        commit_id=raw_id, f_path='vcs/nodes.svg'),
             status=404)
 
         msg = """No such commit exists for this repository"""
         response.mustcontain(msg)
 
     def test_download_file_wrong_f_path(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         f_path = 'vcs/ERRORnodes.py'
 
         response = self.app.get(
             route_path('repo_file_download',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path=f_path),
             status=404)
 
         msg = (
             "There is no file nor directory at the given path: "
             "`%s` at commit %s" % (f_path, commit.short_id))
         response.mustcontain(msg)
 
     def test_file_raw(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='vcs/nodes.py'),)
 
         assert response.content_type == "text/plain"
 
     def test_file_raw_binary(self, backend):
         commit = backend.repo.get_commit()
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id,
                        f_path='docs/theme/ADC/static/breadcrumb_background.png'),)
 
         assert response.content_disposition == 'inline'
 
     def test_raw_file_wrong_cs(self, backend):
         raw_id = u'ERRORcce30c96924232dffcd24178a07ffeb5dfc'
 
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=raw_id, f_path='vcs/nodes.svg'),
             status=404)
 
         msg = """No such commit exists for this repository"""
         response.mustcontain(msg)
 
     def test_raw_wrong_f_path(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         f_path = 'vcs/ERRORnodes.py'
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path=f_path),
             status=404)
 
         msg = (
             "There is no file nor directory at the given path: "
             "`%s` at commit %s" % (f_path, commit.short_id))
         response.mustcontain(msg)
 
     def test_raw_svg_should_not_be_rendered(self, backend):
         backend.create_repo()
         backend.ensure_file("xss.svg")
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='xss.svg'),)
         # If the content type is image/svg+xml then it allows to render HTML
         # and malicious SVG.
         assert response.content_type == "text/plain"
 
 
 @pytest.mark.usefixtures("app")
 class TestRepositoryArchival(object):
 
     def test_archival(self, backend):
         backend.enable_downloads()
         commit = backend.repo.get_commit(commit_idx=173)
         for a_type, content_type, extension in settings.ARCHIVE_SPECS:
 
             short = commit.short_id + extension
             fname = commit.raw_id + extension
             filename = '%s-%s' % (backend.repo_name, short)
             response = self.app.get(
                 route_path('repo_archivefile',
                            repo_name=backend.repo_name,
                            fname=fname))
 
             assert response.status == '200 OK'
             headers = [
                 ('Content-Disposition', 'attachment; filename=%s' % filename),
                 ('Content-Type', '%s' % content_type),
             ]
 
             for header in headers:
                 assert header in response.headers.items()
 
     def test_archival_no_hash(self, backend):
         backend.enable_downloads()
         commit = backend.repo.get_commit(commit_idx=173)
         for a_type, content_type, extension in settings.ARCHIVE_SPECS:
 
             short = 'plain' + extension
             fname = commit.raw_id + extension
             filename = '%s-%s' % (backend.repo_name, short)
             response = self.app.get(
                 route_path('repo_archivefile',
                            repo_name=backend.repo_name,
                            fname=fname, params={'with_hash': 0}))
 
             assert response.status == '200 OK'
             headers = [
                 ('Content-Disposition', 'attachment; filename=%s' % filename),
                 ('Content-Type', '%s' % content_type),
             ]
 
             for header in headers:
                 assert header in response.headers.items()
 
     @pytest.mark.parametrize('arch_ext',[
         'tar', 'rar', 'x', '..ax', '.zipz', 'tar.gz.tar'])
     def test_archival_wrong_ext(self, backend, arch_ext):
         backend.enable_downloads()
         commit = backend.repo.get_commit(commit_idx=173)
 
         fname = commit.raw_id + '.' + arch_ext
 
         response = self.app.get(
             route_path('repo_archivefile',
                        repo_name=backend.repo_name,
                        fname=fname))
         response.mustcontain(
             'Unknown archive type for: `{}`'.format(fname))
 
     @pytest.mark.parametrize('commit_id', [
         '00x000000', 'tar', 'wrong', '@$@$42413232', '232dffcd'])
     def test_archival_wrong_commit_id(self, backend, commit_id):
         backend.enable_downloads()
         fname = '%s.zip' % commit_id
 
         response = self.app.get(
             route_path('repo_archivefile',
                        repo_name=backend.repo_name,
                        fname=fname))
         response.mustcontain('Unknown commit_id')
 
 
 @pytest.mark.usefixtures("app")
 class TestFilesDiff(object):
 
     @pytest.mark.parametrize("diff", ['diff', 'download', 'raw'])
     def test_file_full_diff(self, backend, diff):
         commit1 = backend.repo.get_commit(commit_idx=-1)
         commit2 = backend.repo.get_commit(commit_idx=-2)
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend.repo_name,
                        f_path='README'),
             params={
                 'diff1': commit2.raw_id,
                 'diff2': commit1.raw_id,
                 'fulldiff': '1',
                 'diff': diff,
             })
 
         if diff == 'diff':
             # use redirect since this is OLD view redirecting to compare page
             response = response.follow()
 
         # It's a symlink to README.rst
         response.mustcontain('README.rst')
         response.mustcontain('No newline at end of file')
 
     def test_file_binary_diff(self, backend):
         commits = [
             {'message': 'First commit'},
             {'message': 'Commit with binary',
              'added': [nodes.FileNode('file.bin', content='\0BINARY\0')]},
         ]
         repo = backend.create_repo(commits=commits)
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend.repo_name,
                        f_path='file.bin'),
             params={
                 'diff1': repo.get_commit(commit_idx=0).raw_id,
                 'diff2': repo.get_commit(commit_idx=1).raw_id,
                 'fulldiff': '1',
                 'diff': 'diff',
             })
         # use redirect since this is OLD view redirecting to compare page
         response = response.follow()
         response.mustcontain('Collapse 1 commit')
         file_changes = (1, 0, 0)
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(*file_changes)
 
         if backend.alias == 'svn':
             response.mustcontain('new file 10644')
             # TODO(marcink): SVN doesn't yet detect binary changes
         else:
             response.mustcontain('new file 100644')
             response.mustcontain('binary diff hidden')
 
     def test_diff_2way(self, backend):
         commit1 = backend.repo.get_commit(commit_idx=-1)
         commit2 = backend.repo.get_commit(commit_idx=-2)
         response = self.app.get(
             route_path('repo_files_diff_2way_redirect',
                        repo_name=backend.repo_name,
                        f_path='README'),
             params={
                 'diff1': commit2.raw_id,
                 'diff2': commit1.raw_id,
             })
         # use redirect since this is OLD view redirecting to compare page
         response = response.follow()
 
         # It's a symlink to README.rst
         response.mustcontain('README.rst')
         response.mustcontain('No newline at end of file')
 
     def test_requires_one_commit_id(self, backend, autologin_user):
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend.repo_name,
                        f_path='README.rst'),
             status=400)
         response.mustcontain(
             'Need query parameter', 'diff1', 'diff2', 'to generate a diff.')
 
     def test_returns_no_files_if_file_does_not_exist(self, vcsbackend):
         repo = vcsbackend.repo
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=repo.name,
                        f_path='does-not-exist-in-any-commit'),
             params={
                 'diff1': repo[0].raw_id,
                 'diff2': repo[1].raw_id
             })
 
         response = response.follow()
         response.mustcontain('No files')
 
     def test_returns_redirect_if_file_not_changed(self, backend):
         commit = backend.repo.get_commit(commit_idx=-1)
         response = self.app.get(
             route_path('repo_files_diff_2way_redirect',
                        repo_name=backend.repo_name,
                        f_path='README'),
             params={
                 'diff1': commit.raw_id,
                 'diff2': commit.raw_id,
             })
 
         response = response.follow()
         response.mustcontain('No files')
         response.mustcontain('No commits in this compare')
 
     def test_supports_diff_to_different_path_svn(self, backend_svn):
         #TODO: check this case
         return
 
         repo = backend_svn['svn-simple-layout'].scm_instance()
         commit_id_1 = '24'
         commit_id_2 = '26'
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend_svn.repo_name,
                        f_path='trunk/example.py'),
             params={
                 'diff1': 'tags/v0.2/example.py@' + commit_id_1,
                 'diff2': commit_id_2,
             })
 
         response = response.follow()
         response.mustcontain(
             # diff contains this
             "Will print out a useful message on invocation.")
 
         # Note: Expecting that we indicate the user what's being compared
         response.mustcontain("trunk/example.py")
         response.mustcontain("tags/v0.2/example.py")
 
     def test_show_rev_redirects_to_svn_path(self, backend_svn):
         #TODO: check this case
         return
 
         repo = backend_svn['svn-simple-layout'].scm_instance()
         commit_id = repo[-1].raw_id
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend_svn.repo_name,
                        f_path='trunk/example.py'),
             params={
                 'diff1': 'branches/argparse/example.py@' + commit_id,
                 'diff2': commit_id,
             },
             status=302)
         response = response.follow()
         assert response.headers['Location'].endswith(
             'svn-svn-simple-layout/files/26/branches/argparse/example.py')
 
     def test_show_rev_and_annotate_redirects_to_svn_path(self, backend_svn):
         #TODO: check this case
         return
 
         repo = backend_svn['svn-simple-layout'].scm_instance()
         commit_id = repo[-1].raw_id
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend_svn.repo_name,
                        f_path='trunk/example.py'),
             params={
                 'diff1': 'branches/argparse/example.py@' + commit_id,
                 'diff2': commit_id,
                 'show_rev': 'Show at Revision',
                 'annotate': 'true',
             },
             status=302)
         response = response.follow()
         assert response.headers['Location'].endswith(
             'svn-svn-simple-layout/annotate/26/branches/argparse/example.py')
 
 
 @pytest.mark.usefixtures("app", "autologin_user")
 class TestModifyFilesWithWebInterface(object):
 
     def test_add_file_view(self, backend):
         self.app.get(
             route_path('repo_files_add_file',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/')
             )
 
     @pytest.mark.xfail_backends("svn", reason="Depends on online editing")
     def test_add_file_into_repo_missing_content(self, backend, csrf_token):
         backend.create_repo()
         filename = 'init.py'
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'),
             params={
                 'content': "",
                 'filename': filename,
                 'csrf_token': csrf_token,
             },
             status=302)
         expected_msg = 'Successfully committed new file `{}`'.format(os.path.join(filename))
         assert_session_flash(response, expected_msg)
 
     def test_add_file_into_repo_missing_filename(self, backend, csrf_token):
         commit_id = backend.repo.get_commit().raw_id
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=backend.repo_name,
                        commit_id=commit_id, f_path='/'),
             params={
                 'content': "foo",
                 'csrf_token': csrf_token,
             },
             status=302)
 
         assert_session_flash(response, 'No filename specified')
 
     def test_add_file_into_repo_errors_and_no_commits(
             self, backend, csrf_token):
         repo = backend.create_repo()
         # Create a file with no filename, it will display an error but
         # the repo has no commits yet
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'),
             params={
                 'content': "foo",
                 'csrf_token': csrf_token,
             },
             status=302)
 
         assert_session_flash(response, 'No filename specified')
 
         # Not allowed, redirect to the summary
         redirected = response.follow()
         summary_url = h.route_path('repo_summary', repo_name=repo.repo_name)
 
         # As there are no commits, displays the summary page with the error of
         # creating a file with no filename
 
         assert redirected.request.path == summary_url
 
     @pytest.mark.parametrize("filename, clean_filename", [
         ('/abs/foo', 'abs/foo'),
         ('../rel/foo', 'rel/foo'),
         ('file/../foo/foo', 'file/foo/foo'),
     ])
     def test_add_file_into_repo_bad_filenames(self, filename, clean_filename, backend, csrf_token):
         repo = backend.create_repo()
         commit_id = repo.get_commit().raw_id
 
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=repo.repo_name,
                        commit_id=commit_id, f_path='/'),
             params={
                 'content': "foo",
                 'filename': filename,
                 'csrf_token': csrf_token,
             },
             status=302)
 
         expected_msg = 'Successfully committed new file `{}`'.format(clean_filename)
         assert_session_flash(response, expected_msg)
 
     @pytest.mark.parametrize("cnt, filename, content", [
         (1, 'foo.txt', "Content"),
         (2, 'dir/foo.rst', "Content"),
         (3, 'dir/foo-second.rst', "Content"),
         (4, 'rel/dir/foo.bar', "Content"),
     ])
     def test_add_file_into_empty_repo(self, cnt, filename, content, backend, csrf_token):
         repo = backend.create_repo()
         commit_id = repo.get_commit().raw_id
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=repo.repo_name,
                        commit_id=commit_id, f_path='/'),
             params={
                 'content': content,
                 'filename': filename,
                 'csrf_token': csrf_token,
             },
             status=302)
 
         expected_msg = 'Successfully committed new file `{}`'.format(filename)
         assert_session_flash(response, expected_msg)
 
     def test_edit_file_view(self, backend):
         response = self.app.get(
             route_path('repo_files_edit_file',
                        repo_name=backend.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             status=200)
         response.mustcontain("Module holding everything related to vcs nodes.")
 
     def test_edit_file_view_not_on_branch(self, backend):
         repo = backend.create_repo()
         backend.ensure_file("vcs/nodes.py")
 
         response = self.app.get(
             route_path('repo_files_edit_file',
                        repo_name=repo.repo_name,
                        commit_id='tip',
                        f_path='vcs/nodes.py'),
             status=302)
         assert_session_flash(
             response, 'Cannot modify file. Given commit `tip` is not head of a branch.')
 
     def test_edit_file_view_commit_changes(self, backend, csrf_token):
         repo = backend.create_repo()
         backend.ensure_file("vcs/nodes.py", content="print 'hello'")
 
         response = self.app.post(
             route_path('repo_files_update_file',
                        repo_name=repo.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             params={
                 'content': "print 'hello world'",
                 'message': 'I committed',
                 'filename': "vcs/nodes.py",
                 'csrf_token': csrf_token,
             },
             status=302)
         assert_session_flash(
             response, 'Successfully committed changes to file `vcs/nodes.py`')
         tip = repo.get_commit(commit_idx=-1)
         assert tip.message == 'I committed'
 
     def test_edit_file_view_commit_changes_default_message(self, backend,
                                                            csrf_token):
         repo = backend.create_repo()
         backend.ensure_file("vcs/nodes.py", content="print 'hello'")
 
         commit_id = (
             backend.default_branch_name or
             backend.repo.scm_instance().commit_ids[-1])
 
         response = self.app.post(
             route_path('repo_files_update_file',
                        repo_name=repo.repo_name,
                        commit_id=commit_id,
                        f_path='vcs/nodes.py'),
             params={
                 'content': "print 'hello world'",
                 'message': '',
                 'filename': "vcs/nodes.py",
                 'csrf_token': csrf_token,
             },
             status=302)
         assert_session_flash(
             response, 'Successfully committed changes to file `vcs/nodes.py`')
         tip = repo.get_commit(commit_idx=-1)
         assert tip.message == 'Edited file vcs/nodes.py via RhodeCode Enterprise'
 
     def test_delete_file_view(self, backend):
         self.app.get(
             route_path('repo_files_remove_file',
                        repo_name=backend.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             status=200)
 
     def test_delete_file_view_not_on_branch(self, backend):
         repo = backend.create_repo()
         backend.ensure_file('vcs/nodes.py')
 
         response = self.app.get(
             route_path('repo_files_remove_file',
                        repo_name=repo.repo_name,
                        commit_id='tip',
                        f_path='vcs/nodes.py'),
             status=302)
         assert_session_flash(
             response, 'Cannot modify file. Given commit `tip` is not head of a branch.')
 
     def test_delete_file_view_commit_changes(self, backend, csrf_token):
         repo = backend.create_repo()
         backend.ensure_file("vcs/nodes.py")
 
         response = self.app.post(
             route_path('repo_files_delete_file',
                        repo_name=repo.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             params={
                 'message': 'i committed',
                 'csrf_token': csrf_token,
             },
             status=302)
         assert_session_flash(
             response, 'Successfully deleted file `vcs/nodes.py`')
 
 
 @pytest.mark.usefixtures("app")
 class TestFilesViewOtherCases(object):
 
     def test_access_empty_repo_redirect_to_summary_with_alert_write_perms(
             self, backend_stub, autologin_regular_user, user_regular,
             user_util):
 
         repo = backend_stub.create_repo()
         user_util.grant_user_permission_to_repo(
             repo, user_regular, 'repository.write')
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
 
         repo_file_add_url = route_path(
             'repo_files_add_file',
             repo_name=repo.repo_name,
             commit_id=0, f_path='')
 
         assert_session_flash(
             response,
             'There are no files yet. <a class="alert-link" '
             'href="{}">Click here to add a new file.</a>'
             .format(repo_file_add_url))
 
     def test_access_empty_repo_redirect_to_summary_with_alert_no_write_perms(
             self, backend_stub, autologin_regular_user):
         repo = backend_stub.create_repo()
         # init session for anon user
         route_path('repo_summary', repo_name=repo.repo_name)
 
         repo_file_add_url = route_path(
             'repo_files_add_file',
             repo_name=repo.repo_name,
             commit_id=0, f_path='')
 
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
 
         assert_session_flash(response, no_=repo_file_add_url)
 
     @pytest.mark.parametrize('file_node', [
         'archive/file.zip',
         'diff/my-file.txt',
         'render.py',
         'render',
         'remove_file',
         'remove_file/to-delete.txt',
     ])
     def test_file_names_equal_to_routes_parts(self, backend, file_node):
         backend.create_repo()
         backend.ensure_file(file_node)
 
         self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path=file_node),
             status=200)
 
 
 class TestAdjustFilePathForSvn(object):
     """
     SVN specific adjustments of node history in RepoFilesView.
     """
 
     def test_returns_path_relative_to_matched_reference(self):
         repo = self._repo(branches=['trunk'])
         self.assert_file_adjustment('trunk/file', 'file', repo)
 
     def test_does_not_modify_file_if_no_reference_matches(self):
         repo = self._repo(branches=['trunk'])
         self.assert_file_adjustment('notes/file', 'notes/file', repo)
 
     def test_does_not_adjust_partial_directory_names(self):
         repo = self._repo(branches=['trun'])
         self.assert_file_adjustment('trunk/file', 'trunk/file', repo)
 
     def test_is_robust_to_patterns_which_prefix_other_patterns(self):
         repo = self._repo(branches=['trunk', 'trunk/new', 'trunk/old'])
         self.assert_file_adjustment('trunk/new/file', 'file', repo)
 
     def assert_file_adjustment(self, f_path, expected, repo):
         result = RepoFilesView.adjust_file_path_for_svn(f_path, repo)
         assert result == expected
 
     def _repo(self, branches=None):
         repo = mock.Mock()
         repo.branches = OrderedDict((name, '0') for name in branches or [])
         repo.tags = {}
         return repo

rhodecode/apps/repository/tests/test_repo_issue_tracker.py

@@ -1,149 +1,149 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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.lib.utils2 import md5
 from rhodecode.model.db import Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel, IssueTrackerSettingsModel
 
 
 def route_path(name, params=None, **kwargs):
     import urllib.request, urllib.parse, urllib.error
 
     base_url = {
         'repo_summary': '/{repo_name}',
         'edit_repo_issuetracker': '/{repo_name}/settings/issue_trackers',
         'edit_repo_issuetracker_test': '/{repo_name}/settings/issue_trackers/test',
         'edit_repo_issuetracker_delete': '/{repo_name}/settings/issue_trackers/delete',
         'edit_repo_issuetracker_update': '/{repo_name}/settings/issue_trackers/update',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
     return base_url
 
 
 @pytest.mark.usefixtures("app")
 class TestRepoIssueTracker(object):
     def test_issuetracker_index(self, autologin_user, backend):
         repo = backend.create_repo()
         response = self.app.get(route_path('edit_repo_issuetracker',
                                 repo_name=repo.repo_name))
         assert response.status_code == 200
 
     def test_add_and_test_issuetracker_patterns(
             self, autologin_user, backend, csrf_token, request, xhr_header):
         pattern = 'issuetracker_pat'
         another_pattern = pattern+'1'
         post_url = route_path(
             'edit_repo_issuetracker_update', repo_name=backend.repo.repo_name)
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'http://url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
             'new_pattern_pattern_1': another_pattern,
             'new_pattern_url_1': '/url1',
             'new_pattern_prefix_1': 'prefix1',
             'new_pattern_description_1': 'description1',
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         self.settings_model = IssueTrackerSettingsModel(repo=backend.repo)
         settings = self.settings_model.get_repo_settings()
         self.uid = md5(pattern)
         assert settings[self.uid]['pat'] == pattern
         self.another_uid = md5(another_pattern)
         assert settings[self.another_uid]['pat'] == another_pattern
 
         # test pattern
         data = {'test_text': 'example of issuetracker_pat replacement',
                 'csrf_token': csrf_token}
         response = self.app.post(
             route_path('edit_repo_issuetracker_test',
                        repo_name=backend.repo.repo_name),
             extra_environ=xhr_header, params=data)
 
-        assert response.body == \
+        assert response.text == \
                'example of <a class="tooltip issue-tracker-link" href="http://url" title="description">prefix</a> replacement'
 
         @request.addfinalizer
         def cleanup():
             self.settings_model.delete_entries(self.uid)
             self.settings_model.delete_entries(self.another_uid)
 
     def test_edit_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, request):
         entry_key = 'issuetracker_pat_'
         pattern = 'issuetracker_pat2'
         old_pattern = 'issuetracker_pat'
         old_uid = md5(old_pattern)
 
         sett = SettingsModel(repo=backend.repo).create_or_update_setting(
             entry_key+old_uid, old_pattern, 'unicode')
         Session().add(sett)
         Session().commit()
         post_url = route_path(
             'edit_repo_issuetracker_update', repo_name=backend.repo.repo_name)
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': '/url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': 'description',
             'uid': old_uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         self.settings_model = IssueTrackerSettingsModel(repo=backend.repo)
         settings = self.settings_model.get_repo_settings()
         self.uid = md5(pattern)
         assert settings[self.uid]['pat'] == pattern
         with pytest.raises(KeyError):
             key = settings[old_uid]
 
         @request.addfinalizer
         def cleanup():
             self.settings_model.delete_entries(self.uid)
 
     def test_delete_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, settings_util, xhr_header):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         entry_key = 'issuetracker_pat_'
         pattern = 'issuetracker_pat3'
         uid = md5(pattern)
         settings_util.create_repo_rhodecode_setting(
             repo=backend.repo, name=entry_key+uid,
             value=entry_key, type_='unicode', cleanup=False)
 
         self.app.post(
             route_path(
                 'edit_repo_issuetracker_delete',
                 repo_name=backend.repo.repo_name),
             {
                 'uid': uid,
                 'csrf_token': csrf_token,
                 '': ''
             }, extra_environ=xhr_header, status=200)
         settings = IssueTrackerSettingsModel(
             repo=Repository.get_by_repo_name(repo_name)).get_repo_settings()
         assert 'rhodecode_%s%s' % (entry_key, uid) not in settings

rhodecode/apps/repository/tests/test_repo_pullrequests.py

@@ -1,1680 +1,1680 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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 mock
 import pytest
 
 import rhodecode
 from rhodecode.lib import helpers as h
 from rhodecode.lib.vcs.backends.base import MergeResponse, MergeFailureReason
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.lib.ext_json import json
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.db import (
     PullRequest, ChangesetStatus, UserLog, Notification, ChangesetComment, Repository)
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.tests import (
     assert_session_flash, TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN)
 
 
 def route_path(name, params=None, **kwargs):
     import urllib.request, urllib.parse, urllib.error
 
     base_url = {
         'repo_changelog': '/{repo_name}/changelog',
         'repo_changelog_file': '/{repo_name}/changelog/{commit_id}/{f_path}',
         'repo_commits': '/{repo_name}/commits',
         'repo_commits_file': '/{repo_name}/commits/{commit_id}/{f_path}',
         'pullrequest_show': '/{repo_name}/pull-request/{pull_request_id}',
         'pullrequest_show_all': '/{repo_name}/pull-request',
         'pullrequest_show_all_data': '/{repo_name}/pull-request-data',
         'pullrequest_repo_refs': '/{repo_name}/pull-request/refs/{target_repo_name:.*?[^/]}',
         'pullrequest_repo_targets': '/{repo_name}/pull-request/repo-destinations',
         'pullrequest_new': '/{repo_name}/pull-request/new',
         'pullrequest_create': '/{repo_name}/pull-request/create',
         'pullrequest_update': '/{repo_name}/pull-request/{pull_request_id}/update',
         'pullrequest_merge': '/{repo_name}/pull-request/{pull_request_id}/merge',
         'pullrequest_delete': '/{repo_name}/pull-request/{pull_request_id}/delete',
         'pullrequest_comment_create': '/{repo_name}/pull-request/{pull_request_id}/comment',
         'pullrequest_comment_delete': '/{repo_name}/pull-request/{pull_request_id}/comment/{comment_id}/delete',
         'pullrequest_comment_edit': '/{repo_name}/pull-request/{pull_request_id}/comment/{comment_id}/edit',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
     return base_url
 
 
 @pytest.mark.usefixtures('app', 'autologin_user')
 @pytest.mark.backends("git", "hg")
 class TestPullrequestsView(object):
 
     def test_index(self, backend):
         self.app.get(route_path(
             'pullrequest_new',
             repo_name=backend.repo_name))
 
     def test_option_menu_create_pull_request_exists(self, backend):
         repo_name = backend.repo_name
         response = self.app.get(h.route_path('repo_summary', repo_name=repo_name))
 
         create_pr_link = '<a href="%s">Create Pull Request</a>' % route_path(
             'pullrequest_new', repo_name=repo_name)
         response.mustcontain(create_pr_link)
 
     def test_create_pr_form_with_raw_commit_id(self, backend):
         repo = backend.repo
 
         self.app.get(
             route_path('pullrequest_new', repo_name=repo.repo_name,
                        commit=repo.get_commit().raw_id),
             status=200)
 
     @pytest.mark.parametrize('pr_merge_enabled', [True, False])
     @pytest.mark.parametrize('range_diff', ["0", "1"])
     def test_show(self, pr_util, pr_merge_enabled, range_diff):
         pull_request = pr_util.create_pull_request(
             mergeable=pr_merge_enabled, enable_notifications=False)
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id,
             params={'range-diff': range_diff}))
 
         for commit_id in pull_request.revisions:
             response.mustcontain(commit_id)
 
         response.mustcontain(pull_request.target_ref_parts.type)
         response.mustcontain(pull_request.target_ref_parts.name)
 
         response.mustcontain('class="pull-request-merge"')
 
         if pr_merge_enabled:
             response.mustcontain('Pull request reviewer approval is pending')
         else:
             response.mustcontain('Server-side pull request merging is disabled.')
 
         if range_diff == "1":
             response.mustcontain('Turn off: Show the diff as commit range')
 
     def test_show_versions_of_pr(self, backend, csrf_token):
         commits = [
             {'message': 'initial-commit',
              'added': [FileNode('test-file.txt', 'LINE1\n')]},
 
             {'message': 'commit-1',
              'changed': [FileNode('test-file.txt', 'LINE1\nLINE2\n')]},
             # Above is the initial version of PR that changes a single line
 
             # from now on we'll add 3x commit adding a nother line on each step
             {'message': 'commit-2',
              'changed': [FileNode('test-file.txt', 'LINE1\nLINE2\nLINE3\n')]},
 
             {'message': 'commit-3',
              'changed': [FileNode('test-file.txt', 'LINE1\nLINE2\nLINE3\nLINE4\n')]},
 
             {'message': 'commit-4',
              'changed': [FileNode('test-file.txt', 'LINE1\nLINE2\nLINE3\nLINE4\nLINE5\n')]},
         ]
 
         commit_ids = backend.create_master_repo(commits)
         target = backend.create_repo(heads=['initial-commit'])
         source = backend.create_repo(heads=['commit-1'])
         source_repo_name = source.repo_name
         target_repo_name = target.repo_name
 
         target_ref = 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name, commit_id=commit_ids['initial-commit'])
         source_ref = 'branch:{branch}:{commit_id}'.format(
              branch=backend.default_branch_name, commit_id=commit_ids['commit-1'])
 
         response = self.app.post(
             route_path('pullrequest_create', repo_name=source.repo_name),
             [
                 ('source_repo', source_repo_name),
                 ('source_ref', source_ref),
                 ('target_repo', target_repo_name),
                 ('target_ref',  target_ref),
                 ('common_ancestor', commit_ids['initial-commit']),
                 ('pullrequest_title', 'Title'),
                 ('pullrequest_desc', 'Description'),
                 ('description_renderer', 'markdown'),
                 ('__start__', 'review_members:sequence'),
                     ('__start__', 'reviewer:mapping'),
                         ('user_id', '1'),
                         ('__start__', 'reasons:sequence'),
                             ('reason', 'Some reason'),
                         ('__end__', 'reasons:sequence'),
                         ('__start__', 'rules:sequence'),
                         ('__end__', 'rules:sequence'),
                         ('mandatory', 'False'),
                     ('__end__', 'reviewer:mapping'),
                 ('__end__', 'review_members:sequence'),
                 ('__start__', 'revisions:sequence'),
                     ('revisions', commit_ids['commit-1']),
                 ('__end__', 'revisions:sequence'),
                 ('user', ''),
                 ('csrf_token', csrf_token),
             ],
             status=302)
 
         location = response.headers['Location']
 
         pull_request_id = location.rsplit('/', 1)[1]
         assert pull_request_id != 'new'
         pull_request = PullRequest.get(int(pull_request_id))
 
         pull_request_id = pull_request.pull_request_id
 
         # Show initial version of PR
         response = self.app.get(
             route_path('pullrequest_show',
                        repo_name=target_repo_name,
                        pull_request_id=pull_request_id))
 
         response.mustcontain('commit-1')
         response.mustcontain(no=['commit-2'])
         response.mustcontain(no=['commit-3'])
         response.mustcontain(no=['commit-4'])
 
         response.mustcontain('cb-addition"></span><span>LINE2</span>')
         response.mustcontain(no=['LINE3'])
         response.mustcontain(no=['LINE4'])
         response.mustcontain(no=['LINE5'])
 
         # update PR #1
         source_repo = Repository.get_by_repo_name(source_repo_name)
         backend.pull_heads(source_repo, heads=['commit-2'])
         response = self.app.post(
             route_path('pullrequest_update',
                        repo_name=target_repo_name, pull_request_id=pull_request_id),
             params={'update_commits': 'true', 'csrf_token': csrf_token})
 
         # update PR #2
         source_repo = Repository.get_by_repo_name(source_repo_name)
         backend.pull_heads(source_repo, heads=['commit-3'])
         response = self.app.post(
             route_path('pullrequest_update',
                        repo_name=target_repo_name, pull_request_id=pull_request_id),
             params={'update_commits': 'true', 'csrf_token': csrf_token})
 
         # update PR #3
         source_repo = Repository.get_by_repo_name(source_repo_name)
         backend.pull_heads(source_repo, heads=['commit-4'])
         response = self.app.post(
             route_path('pullrequest_update',
                        repo_name=target_repo_name, pull_request_id=pull_request_id),
             params={'update_commits': 'true', 'csrf_token': csrf_token})
 
         # Show final version !
         response = self.app.get(
             route_path('pullrequest_show',
                        repo_name=target_repo_name,
                        pull_request_id=pull_request_id))
 
         # 3 updates, and the latest == 4
         response.mustcontain('4 versions available for this pull request')
         response.mustcontain(no=['rhodecode diff rendering error'])
 
         # initial show must have 3 commits, and 3 adds
         response.mustcontain('commit-1')
         response.mustcontain('commit-2')
         response.mustcontain('commit-3')
         response.mustcontain('commit-4')
 
         response.mustcontain('cb-addition"></span><span>LINE2</span>')
         response.mustcontain('cb-addition"></span><span>LINE3</span>')
         response.mustcontain('cb-addition"></span><span>LINE4</span>')
         response.mustcontain('cb-addition"></span><span>LINE5</span>')
 
         # fetch versions
         pr = PullRequest.get(pull_request_id)
         versions = [x.pull_request_version_id for x in pr.versions.all()]
         assert len(versions) == 3
 
         # show v1,v2,v3,v4
         def cb_line(text):
             return 'cb-addition"></span><span>{}</span>'.format(text)
 
         def cb_context(text):
             return '<span class="cb-code"><span class="cb-action cb-context">' \
                    '</span><span>{}</span></span>'.format(text)
 
         commit_tests = {
             # in response, not in response
             1: (['commit-1'], ['commit-2', 'commit-3', 'commit-4']),
             2: (['commit-1', 'commit-2'], ['commit-3', 'commit-4']),
             3: (['commit-1', 'commit-2', 'commit-3'], ['commit-4']),
             4: (['commit-1', 'commit-2', 'commit-3', 'commit-4'], []),
         }
         diff_tests = {
             1: (['LINE2'], ['LINE3', 'LINE4', 'LINE5']),
             2: (['LINE2', 'LINE3'], ['LINE4', 'LINE5']),
             3: (['LINE2', 'LINE3', 'LINE4'], ['LINE5']),
             4: (['LINE2', 'LINE3', 'LINE4', 'LINE5'], []),
         }
         for idx, ver in enumerate(versions, 1):
 
             response = self.app.get(
                 route_path('pullrequest_show',
                            repo_name=target_repo_name,
                            pull_request_id=pull_request_id,
                            params={'version': ver}))
 
             response.mustcontain(no=['rhodecode diff rendering error'])
             response.mustcontain('Showing changes at v{}'.format(idx))
 
             yes, no = commit_tests[idx]
             for y in yes:
                 response.mustcontain(y)
             for n in no:
                 response.mustcontain(no=n)
 
             yes, no = diff_tests[idx]
             for y in yes:
                 response.mustcontain(cb_line(y))
             for n in no:
                 response.mustcontain(no=n)
 
         # show diff between versions
         diff_compare_tests = {
             1: (['LINE3'], ['LINE1', 'LINE2']),
             2: (['LINE3', 'LINE4'], ['LINE1', 'LINE2']),
             3: (['LINE3', 'LINE4', 'LINE5'], ['LINE1', 'LINE2']),
         }
         for idx, ver in enumerate(versions, 1):
             adds, context = diff_compare_tests[idx]
 
             to_ver = ver+1
             if idx == 3:
                 to_ver = 'latest'
 
             response = self.app.get(
                 route_path('pullrequest_show',
                            repo_name=target_repo_name,
                            pull_request_id=pull_request_id,
                            params={'from_version': versions[0], 'version': to_ver}))
 
             response.mustcontain(no=['rhodecode diff rendering error'])
 
             for a in adds:
                 response.mustcontain(cb_line(a))
             for c in context:
                 response.mustcontain(cb_context(c))
 
         # test version v2 -> v3
         response = self.app.get(
             route_path('pullrequest_show',
                        repo_name=target_repo_name,
                        pull_request_id=pull_request_id,
                        params={'from_version': versions[1], 'version': versions[2]}))
 
         response.mustcontain(cb_context('LINE1'))
         response.mustcontain(cb_context('LINE2'))
         response.mustcontain(cb_context('LINE3'))
         response.mustcontain(cb_line('LINE4'))
 
     def test_close_status_visibility(self, pr_util, user_util, csrf_token):
         # Logout
         response = self.app.post(
             h.route_path('logout'),
             params={'csrf_token': csrf_token})
         # Login as regular user
         response = self.app.post(h.route_path('login'),
                                  {'username': TEST_USER_REGULAR_LOGIN,
                                   'password': 'test12'})
 
         pull_request = pr_util.create_pull_request(
             author=TEST_USER_REGULAR_LOGIN)
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id))
 
         response.mustcontain('Server-side pull request merging is disabled.')
 
         assert_response = response.assert_response()
         # for regular user without a merge permissions, we don't see it
         assert_response.no_element_exists('#close-pull-request-action')
 
         user_util.grant_user_permission_to_repo(
             pull_request.target_repo,
             UserModel().get_by_username(TEST_USER_REGULAR_LOGIN),
             'repository.write')
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id))
 
         response.mustcontain('Server-side pull request merging is disabled.')
 
         assert_response = response.assert_response()
         # now regular user has a merge permissions, we have CLOSE button
         assert_response.one_element_exists('#close-pull-request-action')
 
     def test_show_invalid_commit_id(self, pr_util):
         # Simulating invalid revisions which will cause a lookup error
         pull_request = pr_util.create_pull_request()
         pull_request.revisions = ['invalid']
         Session().add(pull_request)
         Session().commit()
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id))
 
         for commit_id in pull_request.revisions:
             response.mustcontain(commit_id)
 
     def test_show_invalid_source_reference(self, pr_util):
         pull_request = pr_util.create_pull_request()
         pull_request.source_ref = 'branch:b:invalid'
         Session().add(pull_request)
         Session().commit()
 
         self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id))
 
     def test_edit_title_description(self, pr_util, csrf_token):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
 
         response = self.app.post(
             route_path('pullrequest_update',
                 repo_name=pull_request.target_repo.repo_name,
                 pull_request_id=pull_request_id),
             params={
                 'edit_pull_request': 'true',
                 'title': 'New title',
                 'description': 'New description',
                 'csrf_token': csrf_token})
 
         assert_session_flash(
             response, u'Pull request title & description updated.',
             category='success')
 
         pull_request = PullRequest.get(pull_request_id)
         assert pull_request.title == 'New title'
         assert pull_request.description == 'New description'
 
     def test_edit_title_description(self, pr_util, csrf_token):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
 
         response = self.app.post(
             route_path('pullrequest_update',
                 repo_name=pull_request.target_repo.repo_name,
                 pull_request_id=pull_request_id),
             params={
                 'edit_pull_request': 'true',
                 'title': 'New title {} {2} {foo}',
                 'description': 'New description',
                 'csrf_token': csrf_token})
 
         assert_session_flash(
             response, u'Pull request title & description updated.',
             category='success')
 
         pull_request = PullRequest.get(pull_request_id)
         assert pull_request.title_safe == 'New title {{}} {{2}} {{foo}}'
 
     def test_edit_title_description_closed(self, pr_util, csrf_token):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         repo_name = pull_request.target_repo.repo_name
         pr_util.close()
 
         response = self.app.post(
             route_path('pullrequest_update',
                        repo_name=repo_name, pull_request_id=pull_request_id),
             params={
                 'edit_pull_request': 'true',
                 'title': 'New title',
                 'description': 'New description',
                 'csrf_token': csrf_token}, status=200)
         assert_session_flash(
             response, u'Cannot update closed pull requests.',
             category='error')
 
     def test_update_invalid_source_reference(self, pr_util, csrf_token):
         from rhodecode.lib.vcs.backends.base import UpdateFailureReason
 
         pull_request = pr_util.create_pull_request()
         pull_request.source_ref = 'branch:invalid-branch:invalid-commit-id'
         Session().add(pull_request)
         Session().commit()
 
         pull_request_id = pull_request.pull_request_id
 
         response = self.app.post(
             route_path('pullrequest_update',
                 repo_name=pull_request.target_repo.repo_name,
                 pull_request_id=pull_request_id),
             params={'update_commits': 'true', 'csrf_token': csrf_token})
 
         expected_msg = str(PullRequestModel.UPDATE_STATUS_MESSAGES[
             UpdateFailureReason.MISSING_SOURCE_REF])
         assert_session_flash(response, expected_msg, category='error')
 
     def test_missing_target_reference(self, pr_util, csrf_token):
         from rhodecode.lib.vcs.backends.base import MergeFailureReason
         pull_request = pr_util.create_pull_request(
             approved=True, mergeable=True)
         unicode_reference = u'branch:invalid-branch:invalid-commit-id'
         pull_request.target_ref = unicode_reference
         Session().add(pull_request)
         Session().commit()
 
         pull_request_id = pull_request.pull_request_id
         pull_request_url = route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.repo_name,
             pull_request_id=pull_request_id)
 
         response = self.app.get(pull_request_url)
         target_ref_id = 'invalid-branch'
         merge_resp = MergeResponse(
             True, True, '', MergeFailureReason.MISSING_TARGET_REF,
             metadata={'target_ref': PullRequest.unicode_to_reference(unicode_reference)})
         response.assert_response().element_contains(
             'div[data-role="merge-message"]', merge_resp.merge_status_message)
 
     def test_comment_and_close_pull_request_custom_message_approved(
             self, pr_util, csrf_token, xhr_header):
 
         pull_request = pr_util.create_pull_request(approved=True)
         pull_request_id = pull_request.pull_request_id
         author = pull_request.user_id
         repo = pull_request.target_repo.repo_id
 
         self.app.post(
             route_path('pullrequest_comment_create',
                        repo_name=pull_request.target_repo.scm_instance().name,
                        pull_request_id=pull_request_id),
             params={
                 'close_pull_request': '1',
                 'text': 'Closing a PR',
                 'csrf_token': csrf_token},
             extra_environ=xhr_header,)
 
         journal = UserLog.query()\
             .filter(UserLog.user_id == author)\
             .filter(UserLog.repository_id == repo) \
             .order_by(UserLog.user_log_id.asc()) \
             .all()
         assert journal[-1].action == 'repo.pull_request.close'
 
         pull_request = PullRequest.get(pull_request_id)
         assert pull_request.is_closed()
 
         status = ChangesetStatusModel().get_status(
             pull_request.source_repo, pull_request=pull_request)
         assert status == ChangesetStatus.STATUS_APPROVED
         comments = ChangesetComment().query() \
             .filter(ChangesetComment.pull_request == pull_request) \
             .order_by(ChangesetComment.comment_id.asc())\
             .all()
         assert comments[-1].text == 'Closing a PR'
 
     def test_comment_force_close_pull_request_rejected(
             self, pr_util, csrf_token, xhr_header):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         PullRequestModel().update_reviewers(
             pull_request_id, [
                 (1, ['reason'], False, 'reviewer', []),
                 (2, ['reason2'], False, 'reviewer', [])],
             pull_request.author)
         author = pull_request.user_id
         repo = pull_request.target_repo.repo_id
 
         self.app.post(
             route_path('pullrequest_comment_create',
                 repo_name=pull_request.target_repo.scm_instance().name,
                 pull_request_id=pull_request_id),
             params={
                 'close_pull_request': '1',
                 'csrf_token': csrf_token},
             extra_environ=xhr_header)
 
         pull_request = PullRequest.get(pull_request_id)
 
         journal = UserLog.query()\
             .filter(UserLog.user_id == author, UserLog.repository_id == repo) \
             .order_by(UserLog.user_log_id.asc()) \
             .all()
         assert journal[-1].action == 'repo.pull_request.close'
 
         # check only the latest status, not the review status
         status = ChangesetStatusModel().get_status(
             pull_request.source_repo, pull_request=pull_request)
         assert status == ChangesetStatus.STATUS_REJECTED
 
     def test_comment_and_close_pull_request(
             self, pr_util, csrf_token, xhr_header):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
 
         response = self.app.post(
             route_path('pullrequest_comment_create',
                        repo_name=pull_request.target_repo.scm_instance().name,
                        pull_request_id=pull_request.pull_request_id),
             params={
                 'close_pull_request': 'true',
                 'csrf_token': csrf_token},
             extra_environ=xhr_header)
 
         assert response.json
 
         pull_request = PullRequest.get(pull_request_id)
         assert pull_request.is_closed()
 
         # check only the latest status, not the review status
         status = ChangesetStatusModel().get_status(
             pull_request.source_repo, pull_request=pull_request)
         assert status == ChangesetStatus.STATUS_REJECTED
 
     def test_comment_and_close_pull_request_try_edit_comment(
             self, pr_util, csrf_token, xhr_header
     ):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         target_scm = pull_request.target_repo.scm_instance()
         target_scm_name = target_scm.name
 
         response = self.app.post(
             route_path(
                 'pullrequest_comment_create',
                 repo_name=target_scm_name,
                 pull_request_id=pull_request_id,
             ),
             params={
                 'close_pull_request': 'true',
                 'csrf_token': csrf_token,
             },
             extra_environ=xhr_header)
 
         assert response.json
 
         pull_request = PullRequest.get(pull_request_id)
         target_scm = pull_request.target_repo.scm_instance()
         target_scm_name = target_scm.name
         assert pull_request.is_closed()
 
         # check only the latest status, not the review status
         status = ChangesetStatusModel().get_status(
             pull_request.source_repo, pull_request=pull_request)
         assert status == ChangesetStatus.STATUS_REJECTED
 
         for comment_id in response.json.keys():
             test_text = 'test'
             response = self.app.post(
                 route_path(
                     'pullrequest_comment_edit',
                     repo_name=target_scm_name,
                     pull_request_id=pull_request_id,
                     comment_id=comment_id,
                 ),
                 extra_environ=xhr_header,
                 params={
                     'csrf_token': csrf_token,
                     'text': test_text,
                 },
                 status=403,
             )
             assert response.status_int == 403
 
     def test_comment_and_comment_edit(self, pr_util, csrf_token, xhr_header):
         pull_request = pr_util.create_pull_request()
         target_scm = pull_request.target_repo.scm_instance()
         target_scm_name = target_scm.name
 
         response = self.app.post(
             route_path(
                 'pullrequest_comment_create',
                 repo_name=target_scm_name,
                 pull_request_id=pull_request.pull_request_id),
             params={
                 'csrf_token': csrf_token,
                 'text': 'init',
             },
             extra_environ=xhr_header,
         )
         assert response.json
 
         for comment_id in response.json.keys():
             assert comment_id
             test_text = 'test'
             self.app.post(
                 route_path(
                     'pullrequest_comment_edit',
                     repo_name=target_scm_name,
                     pull_request_id=pull_request.pull_request_id,
                     comment_id=comment_id,
                 ),
                 extra_environ=xhr_header,
                 params={
                     'csrf_token': csrf_token,
                     'text': test_text,
                     'version': '0',
                 },
 
             )
             text_form_db = ChangesetComment.query().filter(
                 ChangesetComment.comment_id == comment_id).first().text
             assert test_text == text_form_db
 
     def test_comment_and_comment_edit(self, pr_util, csrf_token, xhr_header):
         pull_request = pr_util.create_pull_request()
         target_scm = pull_request.target_repo.scm_instance()
         target_scm_name = target_scm.name
 
         response = self.app.post(
             route_path(
                 'pullrequest_comment_create',
                 repo_name=target_scm_name,
                 pull_request_id=pull_request.pull_request_id),
             params={
                 'csrf_token': csrf_token,
                 'text': 'init',
             },
             extra_environ=xhr_header,
         )
         assert response.json
 
         for comment_id in response.json.keys():
             test_text = 'init'
             response = self.app.post(
                 route_path(
                     'pullrequest_comment_edit',
                     repo_name=target_scm_name,
                     pull_request_id=pull_request.pull_request_id,
                     comment_id=comment_id,
                 ),
                 extra_environ=xhr_header,
                 params={
                     'csrf_token': csrf_token,
                     'text': test_text,
                     'version': '0',
                 },
                 status=404,
 
             )
             assert response.status_int == 404
 
     def test_comment_and_try_edit_already_edited(self, pr_util, csrf_token, xhr_header):
         pull_request = pr_util.create_pull_request()
         target_scm = pull_request.target_repo.scm_instance()
         target_scm_name = target_scm.name
 
         response = self.app.post(
             route_path(
                 'pullrequest_comment_create',
                 repo_name=target_scm_name,
                 pull_request_id=pull_request.pull_request_id),
             params={
                 'csrf_token': csrf_token,
                 'text': 'init',
             },
             extra_environ=xhr_header,
         )
         assert response.json
         for comment_id in response.json.keys():
             test_text = 'test'
             self.app.post(
                 route_path(
                     'pullrequest_comment_edit',
                     repo_name=target_scm_name,
                     pull_request_id=pull_request.pull_request_id,
                     comment_id=comment_id,
                 ),
                 extra_environ=xhr_header,
                 params={
                     'csrf_token': csrf_token,
                     'text': test_text,
                     'version': '0',
                 },
 
             )
             test_text_v2 = 'test_v2'
             response = self.app.post(
                 route_path(
                     'pullrequest_comment_edit',
                     repo_name=target_scm_name,
                     pull_request_id=pull_request.pull_request_id,
                     comment_id=comment_id,
                 ),
                 extra_environ=xhr_header,
                 params={
                     'csrf_token': csrf_token,
                     'text': test_text_v2,
                     'version': '0',
                 },
                 status=409,
             )
             assert response.status_int == 409
 
             text_form_db = ChangesetComment.query().filter(
                 ChangesetComment.comment_id == comment_id).first().text
 
             assert test_text == text_form_db
             assert test_text_v2 != text_form_db
 
     def test_comment_and_comment_edit_permissions_forbidden(
             self, autologin_regular_user, user_regular, user_admin, pr_util,
             csrf_token, xhr_header):
         pull_request = pr_util.create_pull_request(
             author=user_admin.username, enable_notifications=False)
         comment = CommentsModel().create(
             text='test',
             repo=pull_request.target_repo.scm_instance().name,
             user=user_admin,
             pull_request=pull_request,
         )
         response = self.app.post(
             route_path(
                 'pullrequest_comment_edit',
                 repo_name=pull_request.target_repo.scm_instance().name,
                 pull_request_id=pull_request.pull_request_id,
                 comment_id=comment.comment_id,
             ),
             extra_environ=xhr_header,
             params={
                 'csrf_token': csrf_token,
                 'text': 'test_text',
             },
             status=403,
         )
         assert response.status_int == 403
 
     def test_create_pull_request(self, backend, csrf_token):
         commits = [
             {'message': 'ancestor'},
             {'message': 'change'},
             {'message': 'change2'},
         ]
         commit_ids = backend.create_master_repo(commits)
         target = backend.create_repo(heads=['ancestor'])
         source = backend.create_repo(heads=['change2'])
 
         response = self.app.post(
             route_path('pullrequest_create', repo_name=source.repo_name),
             [
                 ('source_repo', source.repo_name),
                 ('source_ref', 'branch:default:' + commit_ids['change2']),
                 ('target_repo', target.repo_name),
                 ('target_ref',  'branch:default:' + commit_ids['ancestor']),
                 ('common_ancestor', commit_ids['ancestor']),
                 ('pullrequest_title', 'Title'),
                 ('pullrequest_desc', 'Description'),
                 ('description_renderer', 'markdown'),
                 ('__start__', 'review_members:sequence'),
                     ('__start__', 'reviewer:mapping'),
                         ('user_id', '1'),
                         ('__start__', 'reasons:sequence'),
                             ('reason', 'Some reason'),
                         ('__end__', 'reasons:sequence'),
                         ('__start__', 'rules:sequence'),
                         ('__end__', 'rules:sequence'),
                         ('mandatory', 'False'),
                     ('__end__', 'reviewer:mapping'),
                 ('__end__', 'review_members:sequence'),
                 ('__start__', 'revisions:sequence'),
                     ('revisions', commit_ids['change']),
                     ('revisions', commit_ids['change2']),
                 ('__end__', 'revisions:sequence'),
                 ('user', ''),
                 ('csrf_token', csrf_token),
             ],
             status=302)
 
         location = response.headers['Location']
         pull_request_id = location.rsplit('/', 1)[1]
         assert pull_request_id != 'new'
         pull_request = PullRequest.get(int(pull_request_id))
 
         # check that we have now both revisions
         assert pull_request.revisions == [commit_ids['change2'], commit_ids['change']]
         assert pull_request.source_ref == 'branch:default:' + commit_ids['change2']
         expected_target_ref = 'branch:default:' + commit_ids['ancestor']
         assert pull_request.target_ref == expected_target_ref
 
     def test_reviewer_notifications(self, backend, csrf_token):
         # We have to use the app.post for this test so it will create the
         # notifications properly with the new PR
         commits = [
             {'message': 'ancestor',
              'added': [FileNode('file_A', content='content_of_ancestor')]},
             {'message': 'change',
              'added': [FileNode('file_a', content='content_of_change')]},
             {'message': 'change-child'},
             {'message': 'ancestor-child', 'parents': ['ancestor'],
              'added': [
                 FileNode('file_B', content='content_of_ancestor_child')]},
             {'message': 'ancestor-child-2'},
         ]
         commit_ids = backend.create_master_repo(commits)
         target = backend.create_repo(heads=['ancestor-child'])
         source = backend.create_repo(heads=['change'])
 
         response = self.app.post(
             route_path('pullrequest_create', repo_name=source.repo_name),
             [
                 ('source_repo', source.repo_name),
                 ('source_ref', 'branch:default:' + commit_ids['change']),
                 ('target_repo', target.repo_name),
                 ('target_ref',  'branch:default:' + commit_ids['ancestor-child']),
                 ('common_ancestor', commit_ids['ancestor']),
                 ('pullrequest_title', 'Title'),
                 ('pullrequest_desc', 'Description'),
                 ('description_renderer', 'markdown'),
                 ('__start__', 'review_members:sequence'),
                     ('__start__', 'reviewer:mapping'),
                         ('user_id', '2'),
                         ('__start__', 'reasons:sequence'),
                             ('reason', 'Some reason'),
                         ('__end__', 'reasons:sequence'),
                         ('__start__', 'rules:sequence'),
                         ('__end__', 'rules:sequence'),
                         ('mandatory', 'False'),
                     ('__end__', 'reviewer:mapping'),
                 ('__end__', 'review_members:sequence'),
                 ('__start__', 'revisions:sequence'),
                     ('revisions', commit_ids['change']),
                 ('__end__', 'revisions:sequence'),
                 ('user', ''),
                 ('csrf_token', csrf_token),
             ],
             status=302)
 
         location = response.headers['Location']
 
         pull_request_id = location.rsplit('/', 1)[1]
         assert pull_request_id != 'new'
         pull_request = PullRequest.get(int(pull_request_id))
 
         # Check that a notification was made
         notifications = Notification.query()\
             .filter(Notification.created_by == pull_request.author.user_id,
                     Notification.type_ == Notification.TYPE_PULL_REQUEST,
                     Notification.subject.contains(
                         "requested a pull request review. !%s" % pull_request_id))
         assert len(notifications.all()) == 1
 
         # Change reviewers and check that a notification was made
         PullRequestModel().update_reviewers(
             pull_request.pull_request_id, [
                 (1, [], False, 'reviewer', [])
             ],
             pull_request.author)
         assert len(notifications.all()) == 2
 
     def test_create_pull_request_stores_ancestor_commit_id(self, backend, csrf_token):
         commits = [
             {'message': 'ancestor',
              'added': [FileNode('file_A', content='content_of_ancestor')]},
             {'message': 'change',
              'added': [FileNode('file_a', content='content_of_change')]},
             {'message': 'change-child'},
             {'message': 'ancestor-child', 'parents': ['ancestor'],
              'added': [
                 FileNode('file_B', content='content_of_ancestor_child')]},
             {'message': 'ancestor-child-2'},
         ]
         commit_ids = backend.create_master_repo(commits)
         target = backend.create_repo(heads=['ancestor-child'])
         source = backend.create_repo(heads=['change'])
 
         response = self.app.post(
             route_path('pullrequest_create', repo_name=source.repo_name),
             [
                 ('source_repo', source.repo_name),
                 ('source_ref', 'branch:default:' + commit_ids['change']),
                 ('target_repo', target.repo_name),
                 ('target_ref',  'branch:default:' + commit_ids['ancestor-child']),
                 ('common_ancestor', commit_ids['ancestor']),
                 ('pullrequest_title', 'Title'),
                 ('pullrequest_desc', 'Description'),
                 ('description_renderer', 'markdown'),
                 ('__start__', 'review_members:sequence'),
                     ('__start__', 'reviewer:mapping'),
                         ('user_id', '1'),
                         ('__start__', 'reasons:sequence'),
                             ('reason', 'Some reason'),
                         ('__end__', 'reasons:sequence'),
                         ('__start__', 'rules:sequence'),
                         ('__end__', 'rules:sequence'),
                         ('mandatory', 'False'),
                     ('__end__', 'reviewer:mapping'),
                 ('__end__', 'review_members:sequence'),
                 ('__start__', 'revisions:sequence'),
                     ('revisions', commit_ids['change']),
                 ('__end__', 'revisions:sequence'),
                 ('user', ''),
                 ('csrf_token', csrf_token),
             ],
             status=302)
 
         location = response.headers['Location']
 
         pull_request_id = location.rsplit('/', 1)[1]
         assert pull_request_id != 'new'
         pull_request = PullRequest.get(int(pull_request_id))
 
         # target_ref has to point to the ancestor's commit_id in order to
         # show the correct diff
         expected_target_ref = 'branch:default:' + commit_ids['ancestor']
         assert pull_request.target_ref == expected_target_ref
 
         # Check generated diff contents
         response = response.follow()
         response.mustcontain(no=['content_of_ancestor'])
         response.mustcontain(no=['content_of_ancestor-child'])
         response.mustcontain('content_of_change')
 
     def test_merge_pull_request_enabled(self, pr_util, csrf_token):
         # Clear any previous calls to rcextensions
         rhodecode.EXTENSIONS.calls.clear()
 
         pull_request = pr_util.create_pull_request(
             approved=True, mergeable=True)
         pull_request_id = pull_request.pull_request_id
         repo_name = pull_request.target_repo.scm_instance().name,
 
         url = route_path('pullrequest_merge',
                          repo_name=str(repo_name[0]),
                          pull_request_id=pull_request_id)
         response = self.app.post(url, params={'csrf_token': csrf_token}).follow()
 
         pull_request = PullRequest.get(pull_request_id)
 
         assert response.status_int == 200
         assert pull_request.is_closed()
         assert_pull_request_status(
             pull_request, ChangesetStatus.STATUS_APPROVED)
 
         # Check the relevant log entries were added
         user_logs = UserLog.query().order_by(UserLog.user_log_id.desc()).limit(3)
         actions = [log.action for log in user_logs]
         pr_commit_ids = PullRequestModel()._get_commit_ids(pull_request)
         expected_actions = [
              u'repo.pull_request.close',
              u'repo.pull_request.merge',
              u'repo.pull_request.comment.create'
         ]
         assert actions == expected_actions
 
         user_logs = UserLog.query().order_by(UserLog.user_log_id.desc()).limit(4)
         actions = [log for log in user_logs]
         assert actions[-1].action == 'user.push'
         assert actions[-1].action_data['commit_ids'] == pr_commit_ids
 
         # Check post_push rcextension was really executed
         push_calls = rhodecode.EXTENSIONS.calls['_push_hook']
         assert len(push_calls) == 1
         unused_last_call_args, last_call_kwargs = push_calls[0]
         assert last_call_kwargs['action'] == 'push'
         assert last_call_kwargs['commit_ids'] == pr_commit_ids
 
     def test_merge_pull_request_disabled(self, pr_util, csrf_token):
         pull_request = pr_util.create_pull_request(mergeable=False)
         pull_request_id = pull_request.pull_request_id
         pull_request = PullRequest.get(pull_request_id)
 
         response = self.app.post(
             route_path('pullrequest_merge',
                 repo_name=pull_request.target_repo.scm_instance().name,
                 pull_request_id=pull_request.pull_request_id),
             params={'csrf_token': csrf_token}).follow()
 
         assert response.status_int == 200
         response.mustcontain(
             'Merge is not currently possible because of below failed checks.')
         response.mustcontain('Server-side pull request merging is disabled.')
 
     @pytest.mark.skip_backends('svn')
     def test_merge_pull_request_not_approved(self, pr_util, csrf_token):
         pull_request = pr_util.create_pull_request(mergeable=True)
         pull_request_id = pull_request.pull_request_id
         repo_name = pull_request.target_repo.scm_instance().name
 
         response = self.app.post(
             route_path('pullrequest_merge',
                        repo_name=repo_name, pull_request_id=pull_request_id),
             params={'csrf_token': csrf_token}).follow()
 
         assert response.status_int == 200
 
         response.mustcontain(
             'Merge is not currently possible because of below failed checks.')
         response.mustcontain('Pull request reviewer approval is pending.')
 
     def test_merge_pull_request_renders_failure_reason(
             self, user_regular, csrf_token, pr_util):
         pull_request = pr_util.create_pull_request(mergeable=True, approved=True)
         pull_request_id = pull_request.pull_request_id
         repo_name = pull_request.target_repo.scm_instance().name
 
         merge_resp = MergeResponse(True, False, 'STUB_COMMIT_ID',
                                    MergeFailureReason.PUSH_FAILED,
                                    metadata={'target': 'shadow repo',
                                              'merge_commit': 'xxx'})
         model_patcher = mock.patch.multiple(
             PullRequestModel,
             merge_repo=mock.Mock(return_value=merge_resp),
             merge_status=mock.Mock(return_value=(None, True, 'WRONG_MESSAGE')))
 
         with model_patcher:
             response = self.app.post(
                 route_path('pullrequest_merge',
                            repo_name=repo_name,
                            pull_request_id=pull_request_id),
                 params={'csrf_token': csrf_token}, status=302)
 
             merge_resp = MergeResponse(True, True, '', MergeFailureReason.PUSH_FAILED,
                                        metadata={'target': 'shadow repo',
                                                  'merge_commit': 'xxx'})
         assert_session_flash(response, merge_resp.merge_status_message)
 
     def test_update_source_revision(self, backend, csrf_token):
         commits = [
             {'message': 'ancestor'},
             {'message': 'change'},
             {'message': 'change-2'},
         ]
         commit_ids = backend.create_master_repo(commits)
         target = backend.create_repo(heads=['ancestor'])
         source = backend.create_repo(heads=['change'])
 
         # create pr from a in source to A in target
         pull_request = PullRequest()
 
         pull_request.source_repo = source
         pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name, commit_id=commit_ids['change'])
 
         pull_request.target_repo = target
         pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name, commit_id=commit_ids['ancestor'])
 
         pull_request.revisions = [commit_ids['change']]
         pull_request.title = u"Test"
         pull_request.description = u"Description"
         pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         pull_request.pull_request_state = PullRequest.STATE_CREATED
         Session().add(pull_request)
         Session().commit()
         pull_request_id = pull_request.pull_request_id
 
         # source has ancestor - change - change-2
         backend.pull_heads(source, heads=['change-2'])
         target_repo_name = target.repo_name
 
         # update PR
         self.app.post(
             route_path('pullrequest_update',
                        repo_name=target_repo_name, pull_request_id=pull_request_id),
             params={'update_commits': 'true', 'csrf_token': csrf_token})
 
         response = self.app.get(
             route_path('pullrequest_show',
                        repo_name=target_repo_name,
                        pull_request_id=pull_request.pull_request_id))
 
         assert response.status_int == 200
         response.mustcontain('Pull request updated to')
         response.mustcontain('with 1 added, 0 removed commits.')
 
         # check that we have now both revisions
         pull_request = PullRequest.get(pull_request_id)
         assert pull_request.revisions == [commit_ids['change-2'], commit_ids['change']]
 
     def test_update_target_revision(self, backend, csrf_token):
         commits = [
             {'message': 'ancestor'},
             {'message': 'change'},
             {'message': 'ancestor-new', 'parents': ['ancestor']},
             {'message': 'change-rebased'},
         ]
         commit_ids = backend.create_master_repo(commits)
         target = backend.create_repo(heads=['ancestor'])
         source = backend.create_repo(heads=['change'])
 
         # create pr from a in source to A in target
         pull_request = PullRequest()
 
         pull_request.source_repo = source
         pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name, commit_id=commit_ids['change'])
 
         pull_request.target_repo = target
         pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name, commit_id=commit_ids['ancestor'])
 
         pull_request.revisions = [commit_ids['change']]
         pull_request.title = u"Test"
         pull_request.description = u"Description"
         pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         pull_request.pull_request_state = PullRequest.STATE_CREATED
 
         Session().add(pull_request)
         Session().commit()
         pull_request_id = pull_request.pull_request_id
 
         # target has ancestor - ancestor-new
         # source has ancestor - ancestor-new - change-rebased
         backend.pull_heads(target, heads=['ancestor-new'])
         backend.pull_heads(source, heads=['change-rebased'])
         target_repo_name = target.repo_name
 
         # update PR
         url = route_path('pullrequest_update',
                          repo_name=target_repo_name,
                          pull_request_id=pull_request_id)
         self.app.post(url,
                       params={'update_commits': 'true', 'csrf_token': csrf_token},
                       status=200)
 
         # check that we have now both revisions
         pull_request = PullRequest.get(pull_request_id)
         assert pull_request.revisions == [commit_ids['change-rebased']]
         assert pull_request.target_ref == 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name, commit_id=commit_ids['ancestor-new'])
 
         response = self.app.get(
             route_path('pullrequest_show',
                        repo_name=target_repo_name,
                        pull_request_id=pull_request.pull_request_id))
         assert response.status_int == 200
         response.mustcontain('Pull request updated to')
         response.mustcontain('with 1 added, 1 removed commits.')
 
     def test_update_target_revision_with_removal_of_1_commit_git(self, backend_git, csrf_token):
         backend = backend_git
         commits = [
             {'message': 'master-commit-1'},
             {'message': 'master-commit-2-change-1'},
             {'message': 'master-commit-3-change-2'},
 
             {'message': 'feat-commit-1', 'parents': ['master-commit-1']},
             {'message': 'feat-commit-2'},
         ]
         commit_ids = backend.create_master_repo(commits)
         target = backend.create_repo(heads=['master-commit-3-change-2'])
         source = backend.create_repo(heads=['feat-commit-2'])
 
         # create pr from a in source to A in target
         pull_request = PullRequest()
         pull_request.source_repo = source
 
         pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name,
             commit_id=commit_ids['master-commit-3-change-2'])
 
         pull_request.target_repo = target
         pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name, commit_id=commit_ids['feat-commit-2'])
 
         pull_request.revisions = [
             commit_ids['feat-commit-1'],
             commit_ids['feat-commit-2']
         ]
         pull_request.title = u"Test"
         pull_request.description = u"Description"
         pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         pull_request.pull_request_state = PullRequest.STATE_CREATED
         Session().add(pull_request)
         Session().commit()
         pull_request_id = pull_request.pull_request_id
 
         # PR is created, now we simulate a force-push into target,
         # that drops a 2 last commits
         vcsrepo = target.scm_instance()
         vcsrepo.config.clear_section('hooks')
         vcsrepo.run_git_command(['reset', '--soft', 'HEAD~2'])
         target_repo_name = target.repo_name
 
         # update PR
         url = route_path('pullrequest_update',
                          repo_name=target_repo_name,
                          pull_request_id=pull_request_id)
         self.app.post(url,
                       params={'update_commits': 'true', 'csrf_token': csrf_token},
                       status=200)
 
         response = self.app.get(route_path('pullrequest_new', repo_name=target_repo_name))
         assert response.status_int == 200
         response.mustcontain('Pull request updated to')
         response.mustcontain('with 0 added, 0 removed commits.')
 
     def test_update_of_ancestor_reference(self, backend, csrf_token):
         commits = [
             {'message': 'ancestor'},
             {'message': 'change'},
             {'message': 'change-2'},
             {'message': 'ancestor-new', 'parents': ['ancestor']},
             {'message': 'change-rebased'},
         ]
         commit_ids = backend.create_master_repo(commits)
         target = backend.create_repo(heads=['ancestor'])
         source = backend.create_repo(heads=['change'])
 
         # create pr from a in source to A in target
         pull_request = PullRequest()
         pull_request.source_repo = source
 
         pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name, commit_id=commit_ids['change'])
         pull_request.target_repo = target
         pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name, commit_id=commit_ids['ancestor'])
         pull_request.revisions = [commit_ids['change']]
         pull_request.title = u"Test"
         pull_request.description = u"Description"
         pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         pull_request.pull_request_state = PullRequest.STATE_CREATED
         Session().add(pull_request)
         Session().commit()
         pull_request_id = pull_request.pull_request_id
 
         # target has ancestor - ancestor-new
         # source has ancestor - ancestor-new - change-rebased
         backend.pull_heads(target, heads=['ancestor-new'])
         backend.pull_heads(source, heads=['change-rebased'])
         target_repo_name = target.repo_name
 
         # update PR
         self.app.post(
             route_path('pullrequest_update',
                        repo_name=target_repo_name, pull_request_id=pull_request_id),
             params={'update_commits': 'true', 'csrf_token': csrf_token},
             status=200)
 
         # Expect the target reference to be updated correctly
         pull_request = PullRequest.get(pull_request_id)
         assert pull_request.revisions == [commit_ids['change-rebased']]
         expected_target_ref = 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name,
             commit_id=commit_ids['ancestor-new'])
         assert pull_request.target_ref == expected_target_ref
 
     def test_remove_pull_request_branch(self, backend_git, csrf_token):
         branch_name = 'development'
         commits = [
             {'message': 'initial-commit'},
             {'message': 'old-feature'},
             {'message': 'new-feature', 'branch': branch_name},
         ]
         repo = backend_git.create_repo(commits)
         repo_name = repo.repo_name
         commit_ids = backend_git.commit_ids
 
         pull_request = PullRequest()
         pull_request.source_repo = repo
         pull_request.target_repo = repo
         pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
             branch=branch_name, commit_id=commit_ids['new-feature'])
         pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
             branch=backend_git.default_branch_name, commit_id=commit_ids['old-feature'])
         pull_request.revisions = [commit_ids['new-feature']]
         pull_request.title = u"Test"
         pull_request.description = u"Description"
         pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         pull_request.pull_request_state = PullRequest.STATE_CREATED
         Session().add(pull_request)
         Session().commit()
 
         pull_request_id = pull_request.pull_request_id
 
         vcs = repo.scm_instance()
         vcs.remove_ref('refs/heads/{}'.format(branch_name))
         # NOTE(marcink): run GC to ensure the commits are gone
         vcs.run_gc()
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=repo_name,
             pull_request_id=pull_request_id))
 
         assert response.status_int == 200
 
         response.assert_response().element_contains(
             '#changeset_compare_view_content .alert strong',
             'Missing commits')
         response.assert_response().element_contains(
             '#changeset_compare_view_content .alert',
             'This pull request cannot be displayed, because one or more'
             ' commits no longer exist in the source repository.')
 
     def test_strip_commits_from_pull_request(
             self, backend, pr_util, csrf_token):
         commits = [
             {'message': 'initial-commit'},
             {'message': 'old-feature'},
             {'message': 'new-feature', 'parents': ['initial-commit']},
         ]
         pull_request = pr_util.create_pull_request(
             commits, target_head='initial-commit', source_head='new-feature',
             revisions=['new-feature'])
 
         vcs = pr_util.source_repository.scm_instance()
         if backend.alias == 'git':
             vcs.strip(pr_util.commit_ids['new-feature'], branch_name='master')
         else:
             vcs.strip(pr_util.commit_ids['new-feature'])
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pr_util.target_repository.repo_name,
             pull_request_id=pull_request.pull_request_id))
 
         assert response.status_int == 200
 
         response.assert_response().element_contains(
             '#changeset_compare_view_content .alert strong',
             'Missing commits')
         response.assert_response().element_contains(
             '#changeset_compare_view_content .alert',
             'This pull request cannot be displayed, because one or more'
             ' commits no longer exist in the source repository.')
         response.assert_response().element_contains(
             '#update_commits',
             'Update commits')
 
     def test_strip_commits_and_update(
             self, backend, pr_util, csrf_token):
         commits = [
             {'message': 'initial-commit'},
             {'message': 'old-feature'},
             {'message': 'new-feature', 'parents': ['old-feature']},
         ]
         pull_request = pr_util.create_pull_request(
             commits, target_head='old-feature', source_head='new-feature',
             revisions=['new-feature'], mergeable=True)
         pr_id = pull_request.pull_request_id
         target_repo_name = pull_request.target_repo.repo_name
 
         vcs = pr_util.source_repository.scm_instance()
         if backend.alias == 'git':
             vcs.strip(pr_util.commit_ids['new-feature'], branch_name='master')
         else:
             vcs.strip(pr_util.commit_ids['new-feature'])
 
         url = route_path('pullrequest_update',
                          repo_name=target_repo_name,
                          pull_request_id=pr_id)
         response = self.app.post(url,
                                  params={'update_commits': 'true',
                                          'csrf_token': csrf_token})
 
         assert response.status_int == 200
         assert json.loads(response.body) == json.loads('{"response": true, "redirect_url": null}')
 
         # Make sure that after update, it won't raise 500 errors
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=target_repo_name,
             pull_request_id=pr_id))
 
         assert response.status_int == 200
         response.assert_response().element_contains(
             '#changeset_compare_view_content .alert strong',
             'Missing commits')
 
     def test_branch_is_a_link(self, pr_util):
         pull_request = pr_util.create_pull_request()
         pull_request.source_ref = 'branch:origin:1234567890abcdef'
         pull_request.target_ref = 'branch:target:abcdef1234567890'
         Session().add(pull_request)
         Session().commit()
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id))
         assert response.status_int == 200
 
         source = response.assert_response().get_element('.pr-source-info')
         source_parent = source.getparent()
         assert len(source_parent) == 1
 
         target = response.assert_response().get_element('.pr-target-info')
         target_parent = target.getparent()
         assert len(target_parent) == 1
 
         expected_origin_link = route_path(
             'repo_commits',
             repo_name=pull_request.source_repo.scm_instance().name,
             params=dict(branch='origin'))
         expected_target_link = route_path(
             'repo_commits',
             repo_name=pull_request.target_repo.scm_instance().name,
             params=dict(branch='target'))
         assert source_parent.attrib['href'] == expected_origin_link
         assert target_parent.attrib['href'] == expected_target_link
 
     def test_bookmark_is_not_a_link(self, pr_util):
         pull_request = pr_util.create_pull_request()
         pull_request.source_ref = 'bookmark:origin:1234567890abcdef'
         pull_request.target_ref = 'bookmark:target:abcdef1234567890'
         Session().add(pull_request)
         Session().commit()
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id))
         assert response.status_int == 200
 
         source = response.assert_response().get_element('.pr-source-info')
         assert source.text.strip() == 'bookmark:origin'
         assert source.getparent().attrib.get('href') is None
 
         target = response.assert_response().get_element('.pr-target-info')
         assert target.text.strip() == 'bookmark:target'
         assert target.getparent().attrib.get('href') is None
 
     def test_tag_is_not_a_link(self, pr_util):
         pull_request = pr_util.create_pull_request()
         pull_request.source_ref = 'tag:origin:1234567890abcdef'
         pull_request.target_ref = 'tag:target:abcdef1234567890'
         Session().add(pull_request)
         Session().commit()
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id))
         assert response.status_int == 200
 
         source = response.assert_response().get_element('.pr-source-info')
         assert source.text.strip() == 'tag:origin'
         assert source.getparent().attrib.get('href') is None
 
         target = response.assert_response().get_element('.pr-target-info')
         assert target.text.strip() == 'tag:target'
         assert target.getparent().attrib.get('href') is None
 
     @pytest.mark.parametrize('mergeable', [True, False])
     def test_shadow_repository_link(
             self, mergeable, pr_util, http_host_only_stub):
         """
         Check that the pull request summary page displays a link to the shadow
         repository if the pull request is mergeable. If it is not mergeable
         the link should not be displayed.
         """
         pull_request = pr_util.create_pull_request(
             mergeable=mergeable, enable_notifications=False)
         target_repo = pull_request.target_repo.scm_instance()
         pr_id = pull_request.pull_request_id
         shadow_url = '{host}/{repo}/pull-request/{pr_id}/repository'.format(
             host=http_host_only_stub, repo=target_repo.name, pr_id=pr_id)
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=target_repo.name,
             pull_request_id=pr_id))
 
         if mergeable:
             response.assert_response().element_value_contains(
                 'input.pr-mergeinfo', shadow_url)
             response.assert_response().element_value_contains(
                 'input.pr-mergeinfo ', 'pr-merge')
         else:
             response.assert_response().no_element_exists('.pr-mergeinfo')
 
 
 @pytest.mark.usefixtures('app')
 @pytest.mark.backends("git", "hg")
 class TestPullrequestsControllerDelete(object):
     def test_pull_request_delete_button_permissions_admin(
             self, autologin_user, user_admin, pr_util):
         pull_request = pr_util.create_pull_request(
             author=user_admin.username, enable_notifications=False)
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id))
 
         response.mustcontain('id="delete_pullrequest"')
         response.mustcontain('Confirm to delete this pull request')
 
     def test_pull_request_delete_button_permissions_owner(
             self, autologin_regular_user, user_regular, pr_util):
         pull_request = pr_util.create_pull_request(
             author=user_regular.username, enable_notifications=False)
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id))
 
         response.mustcontain('id="delete_pullrequest"')
         response.mustcontain('Confirm to delete this pull request')
 
     def test_pull_request_delete_button_permissions_forbidden(
             self, autologin_regular_user, user_regular, user_admin, pr_util):
         pull_request = pr_util.create_pull_request(
             author=user_admin.username, enable_notifications=False)
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id))
         response.mustcontain(no=['id="delete_pullrequest"'])
         response.mustcontain(no=['Confirm to delete this pull request'])
 
     def test_pull_request_delete_button_permissions_can_update_cannot_delete(
             self, autologin_regular_user, user_regular, user_admin, pr_util,
             user_util):
 
         pull_request = pr_util.create_pull_request(
             author=user_admin.username, enable_notifications=False)
 
         user_util.grant_user_permission_to_repo(
             pull_request.target_repo, user_regular,
             'repository.write')
 
         response = self.app.get(route_path(
             'pullrequest_show',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id))
 
         response.mustcontain('id="open_edit_pullrequest"')
         response.mustcontain('id="delete_pullrequest"')
         response.mustcontain(no=['Confirm to delete this pull request'])
 
     def test_delete_comment_returns_404_if_comment_does_not_exist(
             self, autologin_user, pr_util, user_admin, csrf_token, xhr_header):
 
         pull_request = pr_util.create_pull_request(
             author=user_admin.username, enable_notifications=False)
 
         self.app.post(
             route_path(
             'pullrequest_comment_delete',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id,
             comment_id=1024404),
             extra_environ=xhr_header,
             params={'csrf_token': csrf_token},
             status=404
         )
 
     def test_delete_comment(
             self, autologin_user, pr_util, user_admin, csrf_token, xhr_header):
 
         pull_request = pr_util.create_pull_request(
             author=user_admin.username, enable_notifications=False)
         comment = pr_util.create_comment()
         comment_id = comment.comment_id
 
         response = self.app.post(
             route_path(
             'pullrequest_comment_delete',
             repo_name=pull_request.target_repo.scm_instance().name,
             pull_request_id=pull_request.pull_request_id,
             comment_id=comment_id),
             extra_environ=xhr_header,
             params={'csrf_token': csrf_token},
             status=200
         )
-        assert response.body == 'true'
+        assert response.text == 'true'
 
     @pytest.mark.parametrize('url_type', [
         'pullrequest_new',
         'pullrequest_create',
         'pullrequest_update',
         'pullrequest_merge',
     ])
     def test_pull_request_is_forbidden_on_archived_repo(
             self, autologin_user, backend, xhr_header, user_util, url_type):
 
         # create a temporary repo
         source = user_util.create_repo(repo_type=backend.alias)
         repo_name = source.repo_name
         repo = Repository.get_by_repo_name(repo_name)
         repo.archived = True
         Session().commit()
 
         response = self.app.get(
             route_path(url_type, repo_name=repo_name, pull_request_id=1), status=302)
 
         msg = 'Action not supported for archived repository.'
         assert_session_flash(response, msg)
 
 
 def assert_pull_request_status(pull_request, expected_status):
     status = ChangesetStatusModel().calculated_review_status(pull_request=pull_request)
     assert status == expected_status
 
 
 @pytest.mark.parametrize('route', ['pullrequest_new', 'pullrequest_create'])
 @pytest.mark.usefixtures("autologin_user")
 def test_forbidde_to_repo_summary_for_svn_repositories(backend_svn, app, route):
     app.get(route_path(route, repo_name=backend_svn.repo_name), status=404)

rhodecode/tests/__init__.py

@@ -1,255 +1,251 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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 time
 import logging
 import datetime
-import hashlib
 import tempfile
 from os.path import join as jn
-
-from tempfile import _RandomNameSequence
+import urllib.parse
 
 import pytest
 
 from rhodecode.model.db import User
 from rhodecode.lib import auth
 from rhodecode.lib import helpers as h
 from rhodecode.lib.helpers import flash
-from rhodecode.lib.utils2 import safe_str
-
+from rhodecode.lib.str_utils import safe_str
+from rhodecode.lib.hash_utils import sha1_safe
 
 log = logging.getLogger(__name__)
 
 __all__ = [
     'get_new_dir', 'TestController', 'route_path_generator',
     'clear_cache_regions',
     'assert_session_flash', 'login_user', 'no_newline_id_generator',
     'TESTS_TMP_PATH', 'HG_REPO', 'GIT_REPO', 'SVN_REPO',
     'NEW_HG_REPO', 'NEW_GIT_REPO',
     'HG_FORK', 'GIT_FORK', 'TEST_USER_ADMIN_LOGIN', 'TEST_USER_ADMIN_PASS',
     'TEST_USER_REGULAR_LOGIN', 'TEST_USER_REGULAR_PASS',
     'TEST_USER_REGULAR_EMAIL', 'TEST_USER_REGULAR2_LOGIN',
     'TEST_USER_REGULAR2_PASS', 'TEST_USER_REGULAR2_EMAIL', 'TEST_HG_REPO',
     'TEST_HG_REPO_CLONE', 'TEST_HG_REPO_PULL', 'TEST_GIT_REPO',
     'TEST_GIT_REPO_CLONE', 'TEST_GIT_REPO_PULL', 'SCM_TESTS',
 ]
 
 
 # SOME GLOBALS FOR TESTS
 TEST_DIR = tempfile.gettempdir()
 
-TESTS_TMP_PATH = jn(TEST_DIR, 'rc_test_{}'.format(next(_RandomNameSequence())))
+TESTS_TMP_PATH = jn(TEST_DIR, 'rc_test_{}'.format(next(tempfile._RandomNameSequence())))
 TEST_USER_ADMIN_LOGIN = 'test_admin'
 TEST_USER_ADMIN_PASS = 'test12'
 TEST_USER_ADMIN_EMAIL = '[e-mail]'
 
 TEST_USER_REGULAR_LOGIN = 'test_regular'
 TEST_USER_REGULAR_PASS = 'test12'
 TEST_USER_REGULAR_EMAIL = '[e-mail]'
 
 TEST_USER_REGULAR2_LOGIN = 'test_regular2'
 TEST_USER_REGULAR2_PASS = 'test12'
 TEST_USER_REGULAR2_EMAIL = '[e-mail]'
 
 HG_REPO = 'vcs_test_hg'
 GIT_REPO = 'vcs_test_git'
 SVN_REPO = 'vcs_test_svn'
 
 NEW_HG_REPO = 'vcs_test_hg_new'
 NEW_GIT_REPO = 'vcs_test_git_new'
 
 HG_FORK = 'vcs_test_hg_fork'
 GIT_FORK = 'vcs_test_git_fork'
 
 ## VCS
 SCM_TESTS = ['hg', 'git']
 uniq_suffix = str(int(time.mktime(datetime.datetime.now().timetuple())))
 
 TEST_GIT_REPO = jn(TESTS_TMP_PATH, GIT_REPO)
-TEST_GIT_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcsgitclone%s' % uniq_suffix)
-TEST_GIT_REPO_PULL = jn(TESTS_TMP_PATH, 'vcsgitpull%s' % uniq_suffix)
+TEST_GIT_REPO_CLONE = jn(TESTS_TMP_PATH, f'vcsgitclone{uniq_suffix}')
+TEST_GIT_REPO_PULL = jn(TESTS_TMP_PATH, f'vcsgitpull{uniq_suffix}')
 
 TEST_HG_REPO = jn(TESTS_TMP_PATH, HG_REPO)
-TEST_HG_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcshgclone%s' % uniq_suffix)
-TEST_HG_REPO_PULL = jn(TESTS_TMP_PATH, 'vcshgpull%s' % uniq_suffix)
+TEST_HG_REPO_CLONE = jn(TESTS_TMP_PATH, f'vcshgclone{uniq_suffix}')
+TEST_HG_REPO_PULL = jn(TESTS_TMP_PATH, f'vcshgpull{uniq_suffix}')
 
 TEST_REPO_PREFIX = 'vcs-test'
 
 
 def clear_cache_regions(regions=None):
     # dogpile
     from rhodecode.lib.rc_cache import region_meta
     for region_name, region in region_meta.dogpile_cache_regions.items():
         if not regions or region_name in regions:
             region.invalidate()
 
 
 def get_new_dir(title):
     """
     Returns always new directory path.
     """
     from rhodecode.tests.vcs.utils import get_normalized_path
     name_parts = [TEST_REPO_PREFIX]
     if title:
         name_parts.append(title)
-    hex_str = hashlib.sha1('%s %s' % (os.getpid(), time.time())).hexdigest()
+    hex_str = sha1_safe(f'{os.getpid()} {time.time()}')
     name_parts.append(hex_str)
     name = '-'.join(name_parts)
     path = os.path.join(TEST_DIR, name)
     return get_normalized_path(path)
 
 
 def repo_id_generator(name):
     numeric_hash = 0
     for char in name:
         numeric_hash += (ord(char))
     return numeric_hash
 
 
 @pytest.mark.usefixtures('app', 'index_location')
 class TestController(object):
 
     maxDiff = None
 
     def log_user(self, username=TEST_USER_ADMIN_LOGIN,
                  password=TEST_USER_ADMIN_PASS):
         self._logged_username = username
         self._session = login_user_session(self.app, username, password)
         self.csrf_token = auth.get_csrf_token(self._session)
 
         return self._session['rhodecode_user']
 
     def logout_user(self):
         logout_user_session(self.app, auth.get_csrf_token(self._session))
         self.csrf_token = None
         self._logged_username = None
         self._session = None
 
     def _get_logged_user(self):
         return User.get_by_username(self._logged_username)
 
 
 def login_user_session(
         app, username=TEST_USER_ADMIN_LOGIN, password=TEST_USER_ADMIN_PASS):
 
     response = app.post(
         h.route_path('login'),
         {'username': username, 'password': password})
-    if 'invalid user name' in response.body:
-        pytest.fail('could not login using %s %s' % (username, password))
+    if 'invalid user name' in response.text:
+        pytest.fail(f'could not login using {username} {password}')
 
     assert response.status == '302 Found'
     response = response.follow()
     assert response.status == '200 OK'
 
     session = response.get_session_from_response()
     assert 'rhodecode_user' in session
     rc_user = session['rhodecode_user']
     assert rc_user.get('username') == username
     assert rc_user.get('is_authenticated')
 
     return session
 
 
 def logout_user_session(app, csrf_token):
     app.post(h.route_path('logout'), {'csrf_token': csrf_token}, status=302)
 
 
 def login_user(app, username=TEST_USER_ADMIN_LOGIN,
                password=TEST_USER_ADMIN_PASS):
     return login_user_session(app, username, password)['rhodecode_user']
 
 
 def assert_session_flash(response, msg=None, category=None, no_=None):
     """
     Assert on a flash message in the current session.
 
     :param response: Response from give calll, it will contain flash
         messages or bound session with them.
     :param msg: The expected message. Will be evaluated if a
         :class:`LazyString` is passed in.
     :param category: Optional. If passed, the message category will be
         checked as well.
     :param no_: Optional. If passed, the message will be checked to NOT
         be in the flash session
     """
     if msg is None and no_ is None:
         raise ValueError("Parameter msg or no_ is required.")
 
     if msg and no_:
         raise ValueError("Please specify either msg or no_, but not both")
 
     session = response.get_session_from_response()
     messages = flash.pop_messages(session=session)
     msg = _eval_if_lazy(msg)
 
     if no_:
-        error_msg = 'unable to detect no_ message `%s` in empty flash list' % no_
+        error_msg = f'unable to detect no_ message `{no_}` in empty flash list'
     else:
-        error_msg = 'unable to find message `%s` in empty flash list' % msg
+        error_msg = f'unable to find message `{msg}` in empty flash list'
     assert messages, error_msg
     message = messages[0]
 
     message_text = _eval_if_lazy(message.message) or ''
 
     if no_:
         if no_ in message_text:
-            msg = u'msg `%s` found in session flash.' % (no_,)
+            msg = f'msg `{no_}` found in session flash.'
             pytest.fail(safe_str(msg))
     else:
         if msg not in message_text:
-            fail_msg = u'msg `%s` not found in session ' \
-                       u'flash: got `%s` (type:%s) instead' % (
-                msg, message_text, type(message_text))
+            fail_msg = f'msg `{msg}` not found in ' \
+                       f'session flash: got `{message_text}` (type:{type(message_text)}) instead'
 
             pytest.fail(safe_str(fail_msg))
         if category:
             assert category == message.category
 
 
 def _eval_if_lazy(value):
     return value.eval() if hasattr(value, 'eval') else value
 
 
 def no_newline_id_generator(test_name):
     """
     Generates a test name without spaces or newlines characters. Used for
     nicer output of progress of test
     """
-    org_name = test_name
+
     test_name = safe_str(test_name)\
         .replace('\n', '_N') \
         .replace('\r', '_N') \
         .replace('\t', '_T') \
         .replace(' ', '_S')
 
     return test_name or 'test-with-empty-name'
 
 
 def route_path_generator(url_defs, name, params=None, **kwargs):
-    import urllib.request, urllib.parse, urllib.error
 
     base_url = url_defs[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
     return base_url

rhodecode/tests/fixture_mods/fixture_pyramid.py

@@ -1,222 +1,222 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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.lib.pyramid_utils import get_app_config
 from rhodecode.tests.fixture import TestINI
 from rhodecode.tests.server_utils import RcVCSServer
 
 
 @pytest.fixture(scope='session')
 def vcsserver(request, vcsserver_port, vcsserver_factory):
     """
     Session scope VCSServer.
 
     Tests wich need the VCSServer have to rely on this fixture in order
     to ensure it will be running.
 
     For specific needs, the fixture vcsserver_factory can be used. It allows to
     adjust the configuration file for the test run.
 
     Command line args:
 
     --without-vcsserver: Allows to switch this fixture off. You have to
     manually start the server.
 
     --vcsserver-port: Will expect the VCSServer to listen on this port.
     """
 
     if not request.config.getoption('with_vcsserver'):
         return None
 
     return vcsserver_factory(
         request, vcsserver_port=vcsserver_port)
 
 
 @pytest.fixture(scope='session')
 def vcsserver_factory(tmpdir_factory):
     """
     Use this if you need a running vcsserver with a special configuration.
     """
 
     def factory(request, overrides=(), vcsserver_port=None,
                 log_file=None):
 
         if vcsserver_port is None:
             vcsserver_port = get_available_port()
 
         overrides = list(overrides)
         overrides.append({'server:main': {'port': vcsserver_port}})
 
         option_name = 'vcsserver_config_http'
         override_option_name = 'vcsserver_config_override'
         config_file = get_config(
             request.config, option_name=option_name,
             override_option_name=override_option_name, overrides=overrides,
             basetemp=tmpdir_factory.getbasetemp().strpath,
             prefix='test_vcs_')
 
         server = RcVCSServer(config_file, log_file)
         server.start()
 
         @request.addfinalizer
         def cleanup():
             server.shutdown()
 
         server.wait_until_ready()
         return server
 
     return factory
 
 
 def _use_log_level(config):
     level = config.getoption('test_loglevel') or 'critical'
     return level.upper()
 
 
 @pytest.fixture(scope='session')
 def ini_config(request, tmpdir_factory, rcserver_port, vcsserver_port):
     option_name = 'pyramid_config'
     log_level = _use_log_level(request.config)
 
     overrides = [
         {'server:main': {'port': rcserver_port}},
         {'app:main': {
             'vcs.server': 'localhost:%s' % vcsserver_port,
             # johbo: We will always start the VCSServer on our own based on the
             # fixtures of the test cases. For the test run it must always be
             # off in the INI file.
             'vcs.start_server': 'false',
 
             'vcs.server.protocol': 'http',
             'vcs.scm_app_implementation': 'http',
             'vcs.hooks.protocol': 'http',
             'vcs.hooks.host': '127.0.0.1',
         }},
 
         {'handler_console': {
             'class': 'StreamHandler',
             'args': '(sys.stderr,)',
             'level': log_level,
         }},
 
     ]
 
     filename = get_config(
         request.config, option_name=option_name,
         override_option_name='{}_override'.format(option_name),
         overrides=overrides,
         basetemp=tmpdir_factory.getbasetemp().strpath,
         prefix='test_rce_')
     return filename
 
 
 @pytest.fixture(scope='session')
 def ini_settings(ini_config):
     ini_path = ini_config
     return get_app_config(ini_path)
 
 
 def get_available_port(min_port=40000, max_port=55555):
     from rhodecode.lib.utils2 import get_available_port as _get_port
     return _get_port(min_port, max_port)
 
 
 @pytest.fixture(scope='session')
 def rcserver_port(request):
     port = get_available_port()
-    print('Using rhodecode port {}'.format(port))
+    print(f'Using rhodecode port {port}')
     return port
 
 
 @pytest.fixture(scope='session')
 def vcsserver_port(request):
     port = request.config.getoption('--vcsserver-port')
     if port is None:
         port = get_available_port()
-        print('Using vcsserver port {}'.format(port))
+        print(f'Using vcsserver port {port}')
     return port
 
 
 @pytest.fixture(scope='session')
 def available_port_factory():
     """
     Returns a callable which returns free port numbers.
     """
     return get_available_port
 
 
 @pytest.fixture()
 def available_port(available_port_factory):
     """
     Gives you one free port for the current test.
 
     Uses "available_port_factory" to retrieve the port.
     """
     return available_port_factory()
 
 
 @pytest.fixture(scope='session')
 def testini_factory(tmpdir_factory, ini_config):
     """
     Factory to create an INI file based on TestINI.
 
     It will make sure to place the INI file in the correct directory.
     """
     basetemp = tmpdir_factory.getbasetemp().strpath
     return TestIniFactory(basetemp, ini_config)
 
 
 class TestIniFactory(object):
 
     def __init__(self, basetemp, template_ini):
         self._basetemp = basetemp
         self._template_ini = template_ini
 
     def __call__(self, ini_params, new_file_prefix='test'):
         ini_file = TestINI(
             self._template_ini, ini_params=ini_params,
             new_file_prefix=new_file_prefix, dir=self._basetemp)
         result = ini_file.create()
         return result
 
 
 def get_config(
         config, option_name, override_option_name, overrides=None,
         basetemp=None, prefix='test'):
     """
     Find a configuration file and apply overrides for the given `prefix`.
     """
     config_file = (
         config.getoption(option_name) or config.getini(option_name))
     if not config_file:
         pytest.exit(
             "Configuration error, could not extract {}.".format(option_name))
 
     overrides = overrides or []
     config_override = config.getoption(override_option_name)
     if config_override:
         overrides.append(config_override)
     temp_ini_file = TestINI(
         config_file, ini_params=overrides, new_file_prefix=prefix,
         dir=basetemp)
 
     return temp_ini_file.create()

rhodecode/tests/fixture_mods/fixture_utils.py

@@ -1,1724 +1,1725 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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 subprocess
 import time
 import uuid
 import dateutil.tz
 import logging
+import functools
 
 import mock
 import pyramid.testing
 import pytest
 import colander
 import requests
 import pyramid.paster
 
 import rhodecode
-from rhodecode.lib.utils2 import AttributeDict
+import rhodecode.lib
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
     PullRequest, PullRequestReviewers, 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.hash_utils import sha1_safe
 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
 
 log = logging.getLogger(__name__)
 
 
 def cmp(a, b):
     # backport cmp from python2 so we can still use it in the custom code in this module
     return (a > b) - (a < b)
 
+
 @pytest.fixture(scope='session', autouse=True)
 def activate_example_rcextensions(request):
     """
     Patch in an example rcextensions module which verifies passed in kwargs.
     """
     from rhodecode.config import rcextensions
 
     old_extensions = rhodecode.EXTENSIONS
     rhodecode.EXTENSIONS = rcextensions
     rhodecode.EXTENSIONS.calls = collections.defaultdict(list)
 
     @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 plain_http_environ()
 
 
 def plain_http_host_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return 'example.com:80'
 
 
 @pytest.fixture()
 def http_host_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return plain_http_host_stub()
 
 
 def plain_http_host_only_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return plain_http_host_stub().split(':')[0]
 
 
 @pytest.fixture()
 def http_host_only_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return plain_http_host_only_stub()
 
 
 def plain_http_environ():
     """
     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': plain_http_host_only_stub(),
         'SERVER_PORT': plain_http_host_stub().split(':')[1],
         'HTTP_HOST': plain_http_host_stub(),
         'HTTP_USER_AGENT': 'rc-test-agent',
         'REQUEST_METHOD': 'GET'
     }
 
 
 @pytest.fixture()
 def http_environ():
     """
     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 plain_http_environ()
 
 
 @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
 
     log.info("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 = get_backend(backend_alias)
         dump_extractor = self.dump_extractors[backend_alias]
         repo_path = dump_extractor(dump_name, repo_name)
 
         vcs_repo = backend(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)
 
 
 def backend_base(request, backend_alias, baseapp, test_repo):
     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(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.
     """
     return backend_base(request, backend_alias, baseapp, test_repo)
 
 
 @pytest.fixture()
 def backend_git(request, baseapp, test_repo):
     return backend_base(request, 'git', baseapp, test_repo)
 
 
 @pytest.fixture()
 def backend_hg(request, baseapp, test_repo):
     return backend_base(request, 'hg', baseapp, test_repo)
 
 
 @pytest.fixture()
 def backend_svn(request, baseapp, test_repo):
     return backend_base(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
     _master_repo_path = ''
     _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)
         self._master_repo_path = self._master_repo.repo_full_path
 
         return self._commit_ids
 
     def create_repo(
             self, commits=None, number_of_commits=0, heads=None,
             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, 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 range(number_of_commits)]
         vcs_repo = repo.scm_instance()
         vcs_repo.count()
         self._add_commits_to_repo(vcs_repo, 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`
         """
         vcsrepo = repo.scm_instance()
         vcsrepo.config.clear_section('hooks')
         commit_ids = [self._commit_ids[h] for h in heads]
         vcsrepo.pull(self._master_repo_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])
 
 
 def vcsbackend_base(request, backend_alias, tests_tmp_path, baseapp, test_repo):
     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(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.
     """
     return vcsbackend_base(request, backend_alias, tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture()
 def vcsbackend_git(request, tests_tmp_path, baseapp, test_repo):
     return vcsbackend_base(request, 'git', tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture()
 def vcsbackend_hg(request, tests_tmp_path, baseapp, test_repo):
     return vcsbackend_base(request, 'hg', tests_tmp_path, baseapp, test_repo)
 
 
 @pytest.fixture()
 def vcsbackend_svn(request, tests_tmp_path, baseapp, test_repo):
     return vcsbackend_base(request, 'svn', tests_tmp_path, baseapp, test_repo)
 
 
 @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,
                     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, bare=bare)
         self._cleanup_repos.append(repo)
 
         commits = commits or [
             {'message': 'Commit %s of %s' % (x, repo_name)}
             for x in range(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 <[e-mail]>')
 
     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 = str(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=str(commit.get('author', 'Automatic <[e-mail]>')),
             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 = subprocess.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, observers=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(),
                 'observers': observers or self._get_observers(),
                 '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):
         role = PullRequestReviewers.ROLE_REVIEWER
         return [
             (TEST_USER_REGULAR_LOGIN, ['default1'], False, role, []),
             (TEST_USER_REGULAR2_LOGIN, ['default2'], False, role, []),
         ]
 
     def _get_observers(self):
         return [
 
         ]
 
     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, self.pull_request.author)
         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, self.pull_request.author)
         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', 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, 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)
+            self.repo_group_ids, key=functools.cmp_to_key(_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)
+            self.user_group_ids, key=functools.cmp_to_key(_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)
 
 
 @pytest.fixture(scope='session')
 def testrun():
     return {
         'uuid': uuid.uuid4(),
         'start': datetime.datetime.utcnow().isoformat(),
         'timestamp': int(time.time()),
     }
 
 
 class AppenlightClient(object):
 
     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()
+        key = key or sha1_safe(f'{section}{value}{repo.repo_id}')
 
         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()
+        key = key or sha1_safe(f'{section}{value}')
 
         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/lib/middleware/test_vcs_unavailable.py

@@ -1,51 +1,51 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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 mock
 import pytest
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 def test_vcs_available_returns_summary_page(app, backend):
     url = '/{repo_name}'.format(repo_name=backend.repo.repo_name)
     response = app.get(url)
     assert response.status_code == 200
-    assert 'Summary' in response.body
+    assert 'Summary' in response.text
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 def test_vcs_unavailable_returns_vcs_error_page(app, backend):
     from rhodecode.lib.vcs.exceptions import VCSCommunicationError
 
     # Depending on the used VCSServer protocol we have to patch a different
     # RemoteRepo class to raise an exception. For the test it doesn't matter
     # if http is used, it just requires the exception to be raised.
     from rhodecode.lib.vcs.client_http import RemoteRepo
 
     url = '/{repo_name}'.format(repo_name=backend.repo.repo_name)
 
     # Patch remote repo to raise an exception instead of making a RPC.
     with mock.patch.object(RemoteRepo, '__getattr__') as remote_mock:
         remote_mock.side_effect = VCSCommunicationError()
 
         response = app.get(url, expect_errors=True)
 
     assert response.status_code == 502
-    assert 'Could not connect to VCS Server' in response.body
+    assert 'Could not connect to VCS Server' in response.text

rhodecode/tests/lib/middleware/utils/test_wsgi_app_caller_client.py

@@ -1,99 +1,99 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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/
 
 from rhodecode.tests.utils import CustomTestApp
 from rhodecode.lib.middleware.utils import wsgi_app_caller_client
 
 # pylint: disable=protected-access,too-many-public-methods
 
 
 BASE_ENVIRON = {
     'REQUEST_METHOD': 'GET',
     'SERVER_NAME': 'localhost',
     'SERVER_PORT': '80',
     'SCRIPT_NAME': '',
     'PATH_INFO': '/',
     'QUERY_STRING': '',
     'foo.bool_var': True,
     'foo.str_var': 'True',
     'wsgi.foo': True,
     # Some non string values. The validator expects to get an iterable as
     # value.
     (42,): '42',
     (True,): 'False',
 }
 
 
 def assert_all_values_are_str(environ):
     """Checks that all values of a dict are str."""
     for key, value in environ.items():
         assert isinstance(value, str), (
             "Value for key %s: has type %s but 'str' was expected. Value: %s" %
             (key, type(value), repr(value)))
 
 
 def assert_all_keys_are_str(environ):
     """Checks that all keys of a dict are str."""
     for key, value in environ.items():
         assert isinstance(value, str), (
             "Key %s: has type %s but 'str' was expected. " %
             (repr(key), type(key)))
 
 
 def assert_no_prefix_in_keys(environ, prefix):
     """Checks that no key of the dict starts with the prefix."""
     for key in environ:
         assert not key.startswith(prefix), 'Key %s should not be present' % key
 
 
 def test_get_environ():
     clean_environ = wsgi_app_caller_client._get_clean_environ(BASE_ENVIRON)
 
     assert len(clean_environ) == 7
     assert_no_prefix_in_keys(clean_environ, 'wsgi.')
     assert_all_keys_are_str(clean_environ)
     assert_all_values_are_str(clean_environ)
 
 
 def test_remote_app_caller():
 
     class RemoteAppCallerMock(object):
 
         def handle(self, environ, input_data, arg1, arg2,
                    arg3=None, arg4=None, arg5=None):
             assert ((arg1, arg2, arg3, arg4, arg5) ==
                     ('a1', 'a2', 'a3', 'a4', None))
             # Note: RemoteAppCaller is expected to return a tuple like the
             # following one
             return (['content'], '200 OK', [('Content-Type', 'text/plain')])
 
     wrapper_app = wsgi_app_caller_client.RemoteAppCaller(
         RemoteAppCallerMock(), 'a1', 'a2', arg3='a3', arg4='a4')
 
     test_app = CustomTestApp(wrapper_app)
 
     response = test_app.get('/path')
 
     assert response.status == '200 OK'
     assert sorted(response.headers.items()) == sorted([
         ('Content-Type', 'text/plain'),
         ('Content-Length', '7'),
     ])
-    assert response.body == 'content'
+    assert response.text == 'content'

rhodecode/tests/lib/test_encrypt.py

@@ -1,133 +1,136 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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.lib.encrypt import (
-    AESCipher, SignatureVerificationError, InvalidDecryptedValue)
-from rhodecode.lib.encrypt2 import (Encryptor, InvalidToken)
+    AESCipher, InvalidDecryptedValue)
+from rhodecode.lib import enc_utils
+from rhodecode.lib.str_utils import safe_str
+from rhodecode.lib.exceptions import SignatureVerificationError
+
+
[e-mail](
+    "algo", ['fernet', 'aes'],
+)
[e-mail](
+    "key, text",
+    [
+        (b'a', 'short'),
+        (b'a' * 64, 'too long(trimmed to 32)'),
+        (b'a' * 32, 'just enough'),
+        ('ąćęćę', 'non asci'),
+        ('$asa$asa', 'special $ used'),
+    ]
+)
[e-mail](
+    "strict_mode", [True, False],
+)
+def test_common_encryption_module(algo, key, text, strict_mode):
+    encrypted = enc_utils.encrypt_value(text, algo=algo, enc_key=key)
+    decrypted = enc_utils.decrypt_value(encrypted, algo=algo, enc_key=key, strict_mode=strict_mode)
+    assert text == safe_str(decrypted)
+
+
[e-mail](
+    "algo", ['fernet', 'aes'],
+)
+def test_encryption_with_bad_key(algo):
+    key = b'secretstring'
+    text = b'ihatemysql'
+
+    encrypted = enc_utils.encrypt_value(text, algo=algo, enc_key=key)
+    decrypted = enc_utils.decrypt_value(encrypted, algo=algo, enc_key=b'different-key', strict_mode=False)
+
+    assert decrypted[:22] == '<InvalidDecryptedValue'
+
+
[e-mail](
+    "algo", ['fernet', 'aes'],
+)
+def test_encryption_with_bad_key_raises(algo):
+    key = b'secretstring'
+    text = b'ihatemysql'
+    encrypted = enc_utils.encrypt_value(text, algo=algo, enc_key=key)
+
+    with pytest.raises(SignatureVerificationError) as e:
+        enc_utils.decrypt_value(encrypted, algo=algo, enc_key=b'different-key', strict_mode=True)
+
+    assert 'InvalidDecryptedValue' in str(e)
 
 
-class TestEncryptModule(object):
-
-    @pytest.mark.parametrize(
-        "key, text",
-        [
-            ('a', 'short'),
-            ('a'*64, 'too long(trimmed to 32)'),
-            ('a'*32, 'just enough'),
-            ('ąćęćę', 'non asci'),
-            ('$asa$asa', 'special $ used'),
-        ]
-    )
-    def test_encryption(self, key, text):
-        enc = AESCipher(key).encrypt(text)
-        assert AESCipher(key).decrypt(enc) == text
-
-    def test_encryption_with_hmac(self):
-        key = 'secret'
-        text = 'ihatemysql'
-        enc = AESCipher(key, hmac=True).encrypt(text)
-        assert AESCipher(key, hmac=True).decrypt(enc) == text
[e-mail](
+    "algo", ['fernet', 'aes'],
+)
+def test_encryption_with_bad_format_data(algo):
+    key = b'secret'
+    text = b'ihatemysql'
+    encrypted = enc_utils.encrypt_value(text, algo=algo, enc_key=key)
+    encrypted = b'$xyz' + encrypted[3:]
 
-    def test_encryption_with_hmac_with_bad_key(self):
-        key = 'secretstring'
-        text = 'ihatemysql'
-        enc = AESCipher(key, hmac=True).encrypt(text)
-
-        with pytest.raises(SignatureVerificationError) as e:
-            assert AESCipher('differentsecret', hmac=True).decrypt(enc) == ''
-
-        assert 'Encryption signature verification failed' in str(e)
+    with pytest.raises(ValueError) as e:
+        enc_utils.decrypt_value(encrypted, algo=algo, enc_key=key, strict_mode=True)
 
-    def test_encryption_with_hmac_with_bad_data(self):
-        key = 'secret'
-        text = 'ihatemysql'
-        enc = AESCipher(key, hmac=True).encrypt(text)
-        enc = 'xyz' + enc[3:]
-        with pytest.raises(SignatureVerificationError) as e:
-            assert AESCipher(key, hmac=True).decrypt(enc) == text
-
-        assert 'Encryption signature verification failed' in str(e)
-
-    def test_encryption_with_hmac_with_bad_key_not_strict(self):
-        key = 'secretstring'
-        text = 'ihatemysql'
-        enc = AESCipher(key, hmac=True).encrypt(text)
-
-        assert isinstance(AESCipher(
-            'differentsecret', hmac=True, strict_verification=False
-        ).decrypt(enc), InvalidDecryptedValue)
+    assert 'Encrypted Data has invalid format' in str(e)
 
 
-class TestEncryptModule2(object):
[e-mail](
+    "algo", ['fernet', 'aes'],
+)
+def test_encryption_with_bad_data(algo):
+    key = b'secret'
+    text = b'ihatemysql'
+    encrypted = enc_utils.encrypt_value(text, algo=algo, enc_key=key)
+    encrypted = encrypted[:-5]
 
-    @pytest.mark.parametrize(
-        "key, text",
-        [
-            ('a', 'short'),
-            ('a'*64, 'too long(trimmed to 32)'),
-            ('a'*32, 'just enough'),
-            ('ąćęćę', 'non asci'),
-            ('$asa$asa', 'special $ used'),
-        ]
-    )
-    def test_encryption(self, key, text):
-        enc = Encryptor(key).encrypt(text)
-        assert Encryptor(key).decrypt(enc) == text
+    with pytest.raises(SignatureVerificationError) as e:
+        enc_utils.decrypt_value(encrypted, algo=algo, enc_key=key, strict_mode=True)
+
+    assert 'SignatureVerificationError' in str(e)
+
 
-    def test_encryption_with_bad_key(self):
-        key = 'secretstring'
-        text = 'ihatemysql'
-        enc = Encryptor(key).encrypt(text)
+def test_encryption_with_hmac():
+    key = b'secret'
+    text = b'ihatemysql'
+    enc = AESCipher(key, hmac=True).encrypt(text)
+    assert AESCipher(key, hmac=True).decrypt(enc) == text
 
-        assert Encryptor('differentsecret').decrypt(enc) == ''
 
-    def test_encryption_with_bad_key_raises(self):
-        key = 'secretstring'
-        text = 'ihatemysql'
-        enc = Encryptor(key).encrypt(text)
-
-        with pytest.raises(InvalidToken) as e:
-            Encryptor('differentsecret').decrypt(enc, safe=False)
+def test_encryption_with_hmac_with_bad_data():
+    key = b'secret'
+    text = b'ihatemysql'
+    enc = AESCipher(key, hmac=True).encrypt(text)
+    enc = b'xyz' + enc[3:]
+    with pytest.raises(SignatureVerificationError) as e:
+        assert AESCipher(key, hmac=True).decrypt(enc, safe=False) == text
 
-        assert 'InvalidToken' in str(e)
+    assert 'SignatureVerificationError' in str(e)
 
-    def test_encryption_with_bad_format_data(self):
-        key = 'secret'
-        text = 'ihatemysql'
-        enc = Encryptor(key).encrypt(text)
-        enc = '$xyz' + enc[3:]
 
-        with pytest.raises(ValueError) as e:
-            Encryptor(key).decrypt(enc, safe=False)
-
-        assert 'Encrypted Data has invalid format' in str(e)
+def test_encryption_with_hmac_with_bad_key_not_strict():
+    key = b'secretstring'
+    text = b'ihatemysql'
+    enc = AESCipher(key, hmac=True).encrypt(text)
 
-    def test_encryption_with_bad_data(self):
-        key = 'secret'
-        text = 'ihatemysql'
-        enc = Encryptor(key).encrypt(text)
-        enc = enc[:-5]
+    decrypted = AESCipher(
+        b'differentsecret', hmac=True, strict_verification=False
+    ).decrypt(enc)
 
-        with pytest.raises(InvalidToken) as e:
-            Encryptor(key).decrypt(enc, safe=False)
-
-        assert 'InvalidToken' in str(e)
+    assert isinstance(decrypted, InvalidDecryptedValue)

rhodecode/tests/load/http_performance.py

@@ -1,463 +1,463 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Module to test the performance of pull, push and clone operations.
 
 It works by replaying a group of commits to the repo.
 """
 
 import argparse
 import collections
 import ConfigParser
 import functools
 import itertools
 import os
 import pprint
 import shutil
 import subprocess
 import sys
 import time
 
 import api
 
 
 def mean(container):
     """Return the mean of the container."""
     if not container:
         return -1.0
     return sum(container) / len(container)
 
 
 def keep_cwd(f):
     """Decorator that keeps track of the starting working directory."""
     @functools.wraps(f)
     def wrapped_f(*args, **kwargs):
         cur_dir = os.getcwd()
         try:
             return f(*args, **kwargs)
         finally:
             os.chdir(cur_dir)
 
     return wrapped_f
 
 
 def timed(f):
     """Decorator that returns the time it took to execute the function."""
     @functools.wraps(f)
     def wrapped_f(*args, **kwargs):
         start_time = time.time()
         try:
             f(*args, **kwargs)
         finally:
             return time.time() - start_time
 
     return wrapped_f
 
 
 def execute(*popenargs, **kwargs):
     """Extension of subprocess.check_output to support writing to stdin."""
     input = kwargs.pop('stdin', None)
     stdin = None
     if input:
         stdin = subprocess.PIPE
     #if 'stderr' not in kwargs:
     #    kwargs['stderr'] = subprocess.PIPE
     if 'stdout' in kwargs:
         raise ValueError('stdout argument not allowed, it will be overridden.')
     process = subprocess.Popen(stdin=stdin, stdout=subprocess.PIPE,
                                *popenargs, **kwargs)
     output, error = process.communicate(input=input)
     retcode = process.poll()
     if retcode:
         cmd = kwargs.get("args")
         if cmd is None:
             cmd = popenargs[0]
         print('{} {} {} '.format(cmd, output, error))
         raise subprocess.CalledProcessError(retcode, cmd, output=output)
     return output
 
 
 def get_repo_name(repo_url):
     """Extract the repo name from its url."""
     repo_url = repo_url.rstrip('/')
     return repo_url.split('/')[-1].split('.')[0]
 
 
 class TestPerformanceBase(object):
     def __init__(self, base_dir, repo_url, n_commits, max_commits,
                  skip_commits):
         self.repo_url = repo_url
         self.repo_name = get_repo_name(self.repo_url)
         self.upstream_repo_name = '%s_upstream' % self.repo_name
         self.base_dir = os.path.abspath(base_dir)
         self.n_commits = n_commits
         self.max_commits = max_commits
         self.skip_commits = skip_commits
         self.push_times = []
         self.pull_times = []
         self.empty_pull_times = []
         self.clone_time = -1.0
         self.last_commit = None
 
         self.cloned_repo = ''
         self.pull_repo = ''
         self.orig_repo = ''
 
     def run(self):
         try:
             self.test()
         except Exception as error:
             print(error)
         finally:
             self.cleanup()
 
             print('Clone time     :{}'.format(self.clone_time))
             print('Push time      :{}'.format(mean(self.push_times)))
             print('Pull time      :{}'.format(mean(self.pull_times)))
             print('Empty pull time:{}'.format(mean(self.empty_pull_times)))
 
             return {
                 'clone': self.clone_time,
                 'push': mean(self.push_times),
                 'pull': mean(self.pull_times),
                 'empty_pull': mean(self.empty_pull_times),
             }
 
     @keep_cwd
     def test(self):
         os.chdir(self.base_dir)
 
         self.orig_repo = os.path.join(self.base_dir, self.repo_name)
         if not os.path.exists(self.orig_repo):
             self.clone_repo(self.repo_url, default_only=True)
 
         upstream_url = self.create_repo(self.upstream_repo_name, self.repo_type)
 
         self.add_remote(self.orig_repo, upstream_url)
 
         self.pull_repo = os.path.join(self.base_dir, '%s_pull' % self.repo_name)
         self.clone_repo(upstream_url, self.pull_repo)
 
         commits = self.get_commits(self.orig_repo)
         self.last_commit = commits[-1]
         if self.skip_commits:
             self.push(
                 self.orig_repo, commits[self.skip_commits - 1], 'upstream')
         commits = commits[self.skip_commits:self.max_commits]
 
         print('Working with %d commits' % len(commits))
         for i in range(self.n_commits - 1, len(commits), self.n_commits):
             commit = commits[i]
             print('Processing commit %s (%d)' % (commit, i + 1))
             self.push_times.append(
                 self.push(self.orig_repo, commit, 'upstream'))
             self.check_remote_last_commit_is(commit, upstream_url)
 
             self.pull_times.append(self.pull(self.pull_repo))
             self.check_local_last_commit_is(commit, self.pull_repo)
 
             self.empty_pull_times.append(self.pull(self.pull_repo))
 
         self.cloned_repo = os.path.join(self.base_dir,
                                         '%s_clone' % self.repo_name)
         self.clone_time = self.clone_repo(upstream_url, self.cloned_repo)
 
     def cleanup(self):
         try:
             self.delete_repo(self.upstream_repo_name)
         except api.ApiError:
             # Continue in case we could not delete the repo. Maybe we did not
             # create it in the first place.
             pass
 
         shutil.rmtree(self.pull_repo, ignore_errors=True)
         shutil.rmtree(self.cloned_repo, ignore_errors=True)
 
         if os.path.exists(self.orig_repo):
             self.remove_remote(self.orig_repo)
 
 
 class RhodeCodeMixin(object):
     """Mixin providing the methods to create and delete repos in RhodeCode."""
     def __init__(self, api_key):
         self.api = api.RCApi(api_key=api_key)
 
     def create_repo(self, repo_name, repo_type):
         return self.api.create_repo(repo_name, repo_type,
                                     'Repo for perfomance testing')
 
     def delete_repo(self, repo_name):
         return self.api.delete_repo(repo_name)
 
 
 class GitMixin(object):
     """Mixin providing the git operations."""
     @timed
     def clone_repo(self, repo_url, destination=None, default_only=False):
         args = ['git', 'clone']
         if default_only:
             args.extend(['--branch', 'master', '--single-branch'])
         args.append(repo_url)
         if destination:
             args.append(destination)
         execute(args)
 
     @keep_cwd
     def add_remote(self, repo, remote_url, remote_name='upstream'):
         self.remove_remote(repo, remote_name)
         os.chdir(repo)
         execute(['git', 'remote', 'add', remote_name, remote_url])
 
     @keep_cwd
     def remove_remote(self, repo, remote_name='upstream'):
         os.chdir(repo)
         remotes = execute(['git', 'remote']).split('\n')
         if remote_name in remotes:
             execute(['git', 'remote', 'remove', remote_name])
 
     @keep_cwd
     def get_commits(self, repo, branch='master'):
         os.chdir(repo)
         commits_list = execute(
             ['git', 'log', '--first-parent', branch, '--pretty=%H'])
         return commits_list.strip().split('\n')[::-1]
 
     @timed
     def push(self, repo, commit, remote_name=None):
         os.chdir(repo)
         try:
             execute(['git', 'reset', '--soft', commit])
             args = ['git', 'push']
             if remote_name:
                 args.append(remote_name)
             execute(args)
         finally:
             execute(['git', 'reset', '--soft', 'HEAD@{1}'])
 
     @timed
     def pull(self, repo):
         os.chdir(repo)
         execute(['git', 'pull'])
 
     def _remote_last_commit(self, repo_url):
         output = execute(['git', 'ls-remote', repo_url, 'HEAD'])
         return output.split()[0]
 
     def check_remote_last_commit_is(self, commit, repo_url):
         last_remote_commit = self._remote_last_commit(repo_url)
         if last_remote_commit != commit:
             raise Exception('Push did not work, expected commit %s but got %s' %
                             (commit, last_remote_commit))
 
     @keep_cwd
     def _local_last_commit(self, repo):
         os.chdir(repo)
         return execute(['git', 'rev-parse', 'HEAD']).strip()
 
     def check_local_last_commit_is(self, commit, repo):
         last_local_commit = self._local_last_commit(repo)
         if last_local_commit != commit:
             raise Exception('Pull did not work, expected commit %s but got %s' %
                             (commit, last_local_commit))
 
 
 class HgMixin(object):
     """Mixin providing the mercurial operations."""
     @timed
     def clone_repo(self, repo_url, destination=None, default_only=False):
         args = ['hg', 'clone']
         if default_only:
             args.extend(['--branch', 'default'])
         args.append(repo_url)
         if destination:
             args.append(destination)
         execute(args)
 
     @keep_cwd
     def add_remote(self, repo, remote_url, remote_name='upstream'):
         self.remove_remote(repo, remote_name)
         os.chdir(repo)
         hgrc = ConfigParser.RawConfigParser()
         hgrc.read('.hg/hgrc')
         hgrc.set('paths', remote_name, remote_url)
         with open('.hg/hgrc', 'w') as f:
             hgrc.write(f)
 
     @keep_cwd
     def remove_remote(self, repo, remote_name='upstream'):
         os.chdir(repo)
         hgrc = ConfigParser.RawConfigParser()
         hgrc.read('.hg/hgrc')
         hgrc.remove_option('paths', remote_name)
         with open('.hg/hgrc', 'w') as f:
             hgrc.write(f)
 
     @keep_cwd
     def get_commits(self, repo, branch='default'):
         os.chdir(repo)
         # See http://stackoverflow.com/questions/15376649/is-there-a-mercurial-equivalent-to-git-log-first-parent
         commits_list = execute(['hg', 'log', '--branch', branch, '--template',
                                 '{node}\n', '--follow-first'])
         return commits_list.strip().split('\n')[::-1]
 
     @timed
     def push(self, repo, commit, remote_name=None):
         os.chdir(repo)
         args = ['hg', 'push', '--rev', commit, '--new-branch']
         if remote_name:
             args.append(remote_name)
         execute(args)
 
     @timed
     def pull(self, repo):
         os.chdir(repo)
         execute(['hg', '--config', 'alias.pull=pull', 'pull', '-u'])
 
     def _remote_last_commit(self, repo_url):
         return execute(['hg', 'identify', repo_url])[:12]
 
     def check_remote_last_commit_is(self, commit, repo_url):
         last_remote_commit = self._remote_last_commit(repo_url)
         if not commit.startswith(last_remote_commit):
             raise Exception('Push did not work, expected commit %s but got %s' %
                             (commit, last_remote_commit))
 
     @keep_cwd
     def _local_last_commit(self, repo):
         os.chdir(repo)
         return execute(['hg', 'identify'])[:12]
 
     def check_local_last_commit_is(self, commit, repo):
         last_local_commit = self._local_last_commit(repo)
         if not commit.startswith(last_local_commit):
             raise Exception('Pull did not work, expected commit %s but got %s' %
                             (commit, last_local_commit))
 
 
 class GitTestPerformance(GitMixin, RhodeCodeMixin, TestPerformanceBase):
     def __init__(self, base_dir, repo_url, n_commits, max_commits, skip_commits,
                  api_key):
         TestPerformanceBase.__init__(self, base_dir, repo_url, n_commits,
                                      max_commits, skip_commits)
         RhodeCodeMixin.__init__(self, api_key)
         self.repo_type = 'git'
 
 
 class HgTestPerformance(HgMixin, RhodeCodeMixin, TestPerformanceBase):
     def __init__(self, base_dir, repo_url, n_commits, max_commits, skip_commits,
                  api_key):
         TestPerformanceBase.__init__(self, base_dir, repo_url, n_commits,
                                      max_commits, skip_commits)
         RhodeCodeMixin.__init__(self, api_key)
         self.repo_type = 'hg'
 
 
 def get_test(base_dir, repo_url, repo_type, step, max_commits, skip_commits,
              api_key):
     max_commits = min(10 * step,
                       int((max_commits - skip_commits) / step) * step)
     max_commits += skip_commits
     if repo_type == 'git':
         return GitTestPerformance(
             base_dir, repo_url, step, max_commits, skip_commits, api_key)
     elif repo_type == 'hg':
         return HgTestPerformance(
             base_dir, repo_url, step, max_commits, skip_commits, api_key)
 
 
 def main(argv):
     parser = argparse.ArgumentParser(
         description='Performance tests for push/pull/clone for git and ' +
                     'mercurial repos.')
     parser.add_argument(
         '--tests', dest='tests', action='store', required=False, default='all',
         help='The tests to run. Default: all. But could be any comma ' +
              'separated list with python, hg, kernel or git')
     parser.add_argument(
         '--sizes', dest='sizes', action='store', required=False,
         default='1,10,100,1000,2500',
         help='The sizes to use. Default: 1,10,100,1000,2500')
     parser.add_argument(
         '--dir', dest='dir', action='store', required=True,
         help='The dir where to store the repos')
     parser.add_argument(
         '--api-key', dest='api_key', action='store', required=True,
         help='The api key of RhodeCode')
     options = parser.parse_args(argv[1:])
     print(options)
 
     test_config = {
         'python': {
             'url': 'https://hg.python.org/cpython/',
             'limit': 23322,
             'type': 'hg',
             # Do not time the first commit, as it is HUGE!
             'skip': 1,
         },
         'hg': {
             'url': 'http://selenic.com/hg',
             'limit': 14396,
             'type': 'hg',
         },
         'kernel': {
             'url': 'https://github.com/torvalds/linux.git',
             'limit': 46271,
             'type': 'git',
         },
         'git': {
             'url': 'https://github.com/git/git.git',
             'limit': 13525,
             'type': 'git',
         }
 
     }
 
     test_names = options.tests.split(',')
     if test_names == ['all']:
         test_names = test_config.keys()
     if not set(test_names) <= set(test_config.keys()):
         print('Invalid tests: only %s are valid but specified %s' %
               (test_config.keys(), test_names))
         return 1
 
     sizes = options.sizes.split(',')
-    sizes = map(int, sizes)
+    sizes = list(map(int, sizes))
 
     base_dir = options.dir
     api_key = options.api_key
     results = collections.defaultdict(dict)
     for test_name, size in itertools.product(test_names, sizes):
         test = get_test(base_dir,
                         test_config[test_name]['url'],
                         test_config[test_name]['type'],
                         size,
                         test_config[test_name]['limit'],
                         test_config[test_name].get('skip', 0),
                         api_key)
         print('*' * 80)
         print('Running performance test: %s with size %d' % (test_name, size))
         print('*' * 80)
         results[test_name][size] = test.run()
     pprint.pprint(dict(results))
 
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv))

rhodecode/tests/utils.py

@@ -1,472 +1,486 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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 threading
 import time
 import logging
 import os.path
 import subprocess
 import tempfile
-import urllib.request, urllib.error, urllib.parse
+import urllib.request
+import urllib.error
+import urllib.parse
 from lxml.html import fromstring, tostring
 from lxml.cssselect import CSSSelector
 from urllib.parse import unquote_plus
 import webob
 
 from webtest.app import TestResponse, TestApp
 from webtest.compat import print_stderr
 
 import pytest
 
 try:
     import rc_testdata
 except ImportError:
     raise ImportError('Failed to import rc_testdata, '
                       'please make sure this package is installed from requirements_test.txt')
 
 from rhodecode.model.db import User, Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.scm import ScmModel
 from rhodecode.lib.vcs.backends.svn.repository import SubversionRepository
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.tests import login_user_session
 
 log = logging.getLogger(__name__)
 
 
 class CustomTestResponse(TestResponse):
 
     def _save_output(self, out):
-        f = tempfile.NamedTemporaryFile(delete=False, prefix='rc-test-', suffix='.html')
+        f = tempfile.NamedTemporaryFile(mode='w', delete=False, prefix='rc-test-', suffix='.html')
         f.write(out)
         return f.name
 
     def mustcontain(self, *strings, **kw):
         """
         Assert that the response contains all of the strings passed
         in as arguments.
 
         Equivalent to::
 
             assert string in res
         """
         print_body = kw.pop('print_body', False)
         if 'no' in kw:
             no = kw['no']
             del kw['no']
             if isinstance(no, str):
                 no = [no]
         else:
             no = []
         if kw:
             raise TypeError(
                 "The only keyword argument allowed is 'no' got %s" % kw)
 
         f = self._save_output(str(self))
 
         for s in strings:
-            if not s in self:
+            if s not in self:
                 print_stderr("Actual response (no %r):" % s)
                 print_stderr("body output saved as `%s`" % f)
                 if print_body:
                     print_stderr(str(self))
                 raise IndexError(
                     "Body does not contain string %r, body output saved as %s" % (s, f))
 
         for no_s in no:
             if no_s in self:
                 print_stderr("Actual response (has %r)" % no_s)
                 print_stderr("body output saved as `%s`" % f)
                 if print_body:
                     print_stderr(str(self))
                 raise IndexError(
                     "Body contains bad string %r, body output saved as %s" % (no_s, f))
 
     def assert_response(self):
         return AssertResponse(self)
 
     def get_session_from_response(self):
         """
         This returns the session from a response object.
         """
         from rhodecode.lib.rc_beaker import session_factory_from_settings
         session = session_factory_from_settings(self.test_app._pyramid_settings)
         return session(self.request)
 
 
 class TestRequest(webob.BaseRequest):
 
-    # for py.test
+    # for py.test, so it doesn't try to run this tas by name starting with test...
     disabled = True
     ResponseClass = CustomTestResponse
 
     def add_response_callback(self, callback):
         pass
 
+    @classmethod
+    def blank(cls, path, environ=None, base_url=None,
+              headers=None, POST=None, **kw):
+
+        if not path.isascii():
+            # our custom quote path if it contains non-ascii chars
+            path = urllib.parse.quote(path)
+
+        return super(TestRequest, cls).blank(
+            path, environ=environ, base_url=base_url, headers=headers, POST=POST, **kw)
+
 
 class CustomTestApp(TestApp):
     """
     Custom app to make mustcontain more Useful, and extract special methods
     """
     RequestClass = TestRequest
     rc_login_data = {}
     rc_current_session = None
 
     def login(self, username=None, password=None):
         from rhodecode.lib import auth
 
         if username and password:
             session = login_user_session(self, username, password)
         else:
             session = login_user_session(self)
 
         self.rc_login_data['csrf_token'] = auth.get_csrf_token(session)
         self.rc_current_session = session
         return session['rhodecode_user']
 
     @property
     def csrf_token(self):
         return self.rc_login_data['csrf_token']
 
     @property
     def _pyramid_registry(self):
         return self.app.config.registry
 
     @property
     def _pyramid_settings(self):
         return self._pyramid_registry.settings
 
 
 def set_anonymous_access(enabled):
     """(Dis)allows anonymous access depending on parameter `enabled`"""
     user = User.get_default_user()
     user.active = enabled
     Session().add(user)
     Session().commit()
     time.sleep(1.5)  # must sleep for cache (1s to expire)
     log.info('anonymous access is now: %s', enabled)
     assert enabled == User.get_default_user().active, (
         'Cannot set anonymous access')
 
 
 def check_xfail_backends(node, backend_alias):
     # Using "xfail_backends" here intentionally, since this marks work
     # which is "to be done" soon.
     skip_marker = node.get_closest_marker('xfail_backends')
     if skip_marker and backend_alias in skip_marker.args:
         msg = "Support for backend %s to be developed." % (backend_alias, )
         msg = skip_marker.kwargs.get('reason', msg)
         pytest.xfail(msg)
 
 
 def check_skip_backends(node, backend_alias):
     # Using "skip_backends" here intentionally, since this marks work which is
     # not supported.
     skip_marker = node.get_closest_marker('skip_backends')
     if skip_marker and backend_alias in skip_marker.args:
         msg = "Feature not supported for backend %s." % (backend_alias, )
         msg = skip_marker.kwargs.get('reason', msg)
         pytest.skip(msg)
 
 
 def extract_git_repo_from_dump(dump_name, repo_name):
     """Create git repo `repo_name` from dump `dump_name`."""
     repos_path = ScmModel().repos_path
     target_path = os.path.join(repos_path, repo_name)
     rc_testdata.extract_git_dump(dump_name, target_path)
     return target_path
 
 
 def extract_hg_repo_from_dump(dump_name, repo_name):
     """Create hg repo `repo_name` from dump `dump_name`."""
     repos_path = ScmModel().repos_path
     target_path = os.path.join(repos_path, repo_name)
     rc_testdata.extract_hg_dump(dump_name, target_path)
     return target_path
 
 
 def extract_svn_repo_from_dump(dump_name, repo_name):
     """Create a svn repo `repo_name` from dump `dump_name`."""
     repos_path = ScmModel().repos_path
     target_path = os.path.join(repos_path, repo_name)
     SubversionRepository(target_path, create=True)
     _load_svn_dump_into_repo(dump_name, target_path)
     return target_path
 
 
 def assert_message_in_log(log_records, message, levelno, module):
     messages = [
         r.message for r in log_records
         if r.module == module and r.levelno == levelno
     ]
     assert message in messages
 
 
 def _load_svn_dump_into_repo(dump_name, repo_path):
     """
     Utility to populate a svn repository with a named dump
 
     Currently the dumps are in rc_testdata. They might later on be
     integrated with the main repository once they stabilize more.
     """
     dump = rc_testdata.load_svn_dump(dump_name)
     load_dump = subprocess.Popen(
         ['svnadmin', 'load', repo_path],
         stdin=subprocess.PIPE, stdout=subprocess.PIPE,
         stderr=subprocess.PIPE)
     out, err = load_dump.communicate(dump)
     if load_dump.returncode != 0:
         log.error("Output of load_dump command: %s", out)
         log.error("Error output of load_dump command: %s", err)
         raise Exception(
             'Failed to load dump "%s" into repository at path "%s".'
             % (dump_name, repo_path))
 
 
 class AssertResponse(object):
     """
     Utility that helps to assert things about a given HTML response.
     """
 
     def __init__(self, response):
         self.response = response
 
     def get_imports(self):
         return fromstring, tostring, CSSSelector
 
     def one_element_exists(self, css_selector):
         self.get_element(css_selector)
 
     def no_element_exists(self, css_selector):
         assert not self._get_elements(css_selector)
 
     def element_equals_to(self, css_selector, expected_content):
         element = self.get_element(css_selector)
         element_text = self._element_to_string(element)
+
         assert expected_content in element_text
 
     def element_contains(self, css_selector, expected_content):
         element = self.get_element(css_selector)
         assert expected_content in element.text_content()
 
     def element_value_contains(self, css_selector, expected_content):
         element = self.get_element(css_selector)
         assert expected_content in element.value
 
     def contains_one_link(self, link_text, href):
         fromstring, tostring, CSSSelector = self.get_imports()
         doc = fromstring(self.response.body)
         sel = CSSSelector('a[href]')
         elements = [
             e for e in sel(doc) if e.text_content().strip() == link_text]
         assert len(elements) == 1, "Did not find link or found multiple links"
         self._ensure_url_equal(elements[0].attrib.get('href'), href)
 
     def contains_one_anchor(self, anchor_id):
         fromstring, tostring, CSSSelector = self.get_imports()
         doc = fromstring(self.response.body)
         sel = CSSSelector('#' + anchor_id)
         elements = sel(doc)
         assert len(elements) == 1, 'cannot find 1 element {}'.format(anchor_id)
 
     def _ensure_url_equal(self, found, expected):
         assert _Url(found) == _Url(expected)
 
     def get_element(self, css_selector):
         elements = self._get_elements(css_selector)
         assert len(elements) == 1, 'cannot find 1 element {}'.format(css_selector)
         return elements[0]
 
     def get_elements(self, css_selector):
         return self._get_elements(css_selector)
 
     def _get_elements(self, css_selector):
         fromstring, tostring, CSSSelector = self.get_imports()
         doc = fromstring(self.response.body)
         sel = CSSSelector(css_selector)
         elements = sel(doc)
         return elements
 
     def _element_to_string(self, element):
         fromstring, tostring, CSSSelector = self.get_imports()
-        return tostring(element)
+        return tostring(element, encoding='unicode')
 
 
 class _Url(object):
     """
     A url object that can be compared with other url orbjects
     without regard to the vagaries of encoding, escaping, and ordering
     of parameters in query strings.
 
     Inspired by
     http://stackoverflow.com/questions/5371992/comparing-two-urls-in-python
     """
 
     def __init__(self, url):
         parts = urllib.parse.urlparse(url)
         _query = frozenset(urllib.parse.parse_qsl(parts.query))
         _path = unquote_plus(parts.path)
         parts = parts._replace(query=_query, path=_path)
         self.parts = parts
 
     def __eq__(self, other):
         return self.parts == other.parts
 
     def __hash__(self):
         return hash(self.parts)
 
 
 def run_test_concurrently(times, raise_catched_exc=True):
     """
     Add this decorator to small pieces of code that you want to test
     concurrently
 
     ex:
 
     @test_concurrently(25)
     def my_test_function():
         ...
     """
     def test_concurrently_decorator(test_func):
         def wrapper(*args, **kwargs):
             exceptions = []
 
             def call_test_func():
                 try:
                     test_func(*args, **kwargs)
                 except Exception as e:
                     exceptions.append(e)
                     if raise_catched_exc:
                         raise
             threads = []
             for i in range(times):
                 threads.append(threading.Thread(target=call_test_func))
             for t in threads:
                 t.start()
             for t in threads:
                 t.join()
             if exceptions:
                 raise Exception(
                     'test_concurrently intercepted %s exceptions: %s' % (
                         len(exceptions), exceptions))
         return wrapper
     return test_concurrently_decorator
 
 
 def wait_for_url(url, timeout=10):
     """
     Wait until URL becomes reachable.
 
     It polls the URL until the timeout is reached or it became reachable.
     If will call to `py.test.fail` in case the URL is not reachable.
     """
     timeout = time.time() + timeout
     last = 0
     wait = 0.1
 
     while timeout > last:
         last = time.time()
         if is_url_reachable(url):
             break
         elif (last + wait) > time.time():
             # Go to sleep because not enough time has passed since last check.
             time.sleep(wait)
     else:
         pytest.fail("Timeout while waiting for URL {}".format(url))
 
 
 def is_url_reachable(url):
     try:
         urllib.request.urlopen(url)
     except urllib.error.URLError:
         log.exception('URL `{}` reach error'.format(url))
         return False
     return True
 
 
 def repo_on_filesystem(repo_name):
     from rhodecode.lib import vcs
     from rhodecode.tests import TESTS_TMP_PATH
     repo = vcs.get_vcs_instance(
         os.path.join(TESTS_TMP_PATH, repo_name), create=False)
     return repo is not None
 
 
 def commit_change(
         repo, filename, content, message, vcs_type, parent=None, newfile=False):
     from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 
     repo = Repository.get_by_repo_name(repo)
     _commit = parent
     if not parent:
         _commit = EmptyCommit(alias=vcs_type)
 
     if newfile:
         nodes = {
             filename: {
                 'content': content
             }
         }
         commit = ScmModel().create_nodes(
             user=TEST_USER_ADMIN_LOGIN, repo=repo,
             message=message,
             nodes=nodes,
             parent_commit=_commit,
             author=f'{TEST_USER_ADMIN_LOGIN} <[e-mail]>',
         )
     else:
         commit = ScmModel().commit_change(
             repo=repo.scm_instance(), repo_name=repo.repo_name,
             commit=parent, user=TEST_USER_ADMIN_LOGIN,
             author=f'{TEST_USER_ADMIN_LOGIN} <[e-mail]>',
             message=message,
             content=content,
             f_path=filename
         )
     return commit
 
 
 def permission_update_data_generator(csrf_token, default=None, grant=None, revoke=None):
     if not default:
         raise ValueError('Permission for default user must be given')
     form_data = [(
         'csrf_token', csrf_token
     )]
     # add default
     form_data.extend([
         ('u_perm_1', default)
     ])
 
     if grant:
         for cnt, (obj_id, perm, obj_name, obj_type) in enumerate(grant, 1):
             form_data.extend([
                 ('perm_new_member_perm_new{}'.format(cnt), perm),
                 ('perm_new_member_id_new{}'.format(cnt), obj_id),
                 ('perm_new_member_name_new{}'.format(cnt), obj_name),
                 ('perm_new_member_type_new{}'.format(cnt), obj_type),
 
             ])
     if revoke:
         for obj_id, obj_type in revoke:
             form_data.extend([
                 ('perm_del_member_id_{}'.format(obj_id), obj_id),
                 ('perm_del_member_type_{}'.format(obj_id), obj_type),
             ])
     return form_data

rhodecode/tests/vcs_operations/__init__.py

@@ -1,193 +1,199 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Base for test suite for making push/pull operations.
 
 .. important::
 
    You must have git >= 1.8.5 for tests to work fine. With 68b939b git started
    to redirect things to stderr instead of stdout.
 """
 
 from os.path import join as jn
 from subprocess import Popen, PIPE
 import logging
 import os
 import tempfile
 
+from rhodecode.lib.str_utils import safe_str
 from rhodecode.tests import GIT_REPO, HG_REPO
 
 DEBUG = True
 RC_LOG = os.path.join(tempfile.gettempdir(), 'rc.log')
 REPO_GROUP = 'a_repo_group'
 HG_REPO_WITH_GROUP = '%s/%s' % (REPO_GROUP, HG_REPO)
 GIT_REPO_WITH_GROUP = '%s/%s' % (REPO_GROUP, GIT_REPO)
 
 log = logging.getLogger(__name__)
 
 
 class Command(object):
 
     def __init__(self, cwd):
         self.cwd = cwd
         self.process = None
 
     def execute(self, cmd, *args):
         """
         Runs command on the system with given ``args``.
         """
 
         command = cmd + ' ' + ' '.join(args)
         if DEBUG:
             log.debug('*** CMD %s ***', command)
 
         env = dict(os.environ)
         # Delete coverage variables, as they make the test fail for Mercurial
         for key in env.keys():
             if key.startswith('COV_CORE_'):
                 del env[key]
 
         self.process = Popen(command, shell=True, stdout=PIPE, stderr=PIPE,
                              cwd=self.cwd, env=env)
         stdout, stderr = self.process.communicate()
+
+        stdout = safe_str(stdout)
+        stderr = safe_str(stderr)
+
         if DEBUG:
             log.debug('STDOUT:%s', stdout)
             log.debug('STDERR:%s', stderr)
         return stdout, stderr
 
     def assert_returncode_success(self):
         assert self.process.returncode == 0
 
 
 def _add_files(vcs, dest, clone_url=None, tags=None, target_branch=None, new_branch=False, **kwargs):
-    git_ident = "git config user.name {} && git config user.email {}".format(
-            'Marcin Kuźminski', '[e-mail]')
+    full_name = 'Marcin Kuźminski'
+    email = '[e-mail]'
+    git_ident = f"git config user.name {full_name} && git config user.email {email}"
     cwd = path = jn(dest)
 
     tags = tags or []
     added_file = jn(path, '{}_setup.py'.format(next(tempfile._RandomNameSequence())))
     Command(cwd).execute('touch %s' % added_file)
     Command(cwd).execute('%s add %s' % (vcs, added_file))
     author_str = 'Marcin Kuźminski <[e-mail]>'
 
     for i in range(kwargs.get('files_no', 3)):
         cmd = """echo 'added_line%s' >> %s""" % (i, added_file)
         Command(cwd).execute(cmd)
 
         if vcs == 'hg':
             cmd = """hg commit -m 'committed new %s' -u '%s' %s """ % (
                 i, author_str, added_file
             )
         elif vcs == 'git':
             cmd = """%s && git commit -m 'committed new %s' %s""" % (
                 git_ident, i, added_file)
         Command(cwd).execute(cmd)
 
     for tag in tags:
         if vcs == 'hg':
             Command(cwd).execute(
                 'hg tag -m "{}" -u "{}" '.format(tag['commit'], author_str), tag['name'])
         elif vcs == 'git':
             if tag['commit']:
                 # annotated tag
                 _stdout, _stderr = Command(cwd).execute(
                     """%s && git tag -a %s -m "%s" """ % (
                         git_ident, tag['name'], tag['commit']))
             else:
                 # lightweight tag
                 _stdout, _stderr = Command(cwd).execute(
                     """%s && git tag %s""" % (
                         git_ident, tag['name']))
 
 
 def _add_files_and_push(vcs, dest, clone_url=None, tags=None, target_branch=None,
                         new_branch=False, **kwargs):
     """
     Generate some files, add it to DEST repo and push back
     vcs is git or hg and defines what VCS we want to make those files for
     """
     git_ident = "git config user.name {} && git config user.email {}".format(
             'Marcin Kuźminski', '[e-mail]')
     cwd = path = jn(dest)
 
     # commit some stuff into this repo
     _add_files(vcs, dest, clone_url, tags, target_branch, new_branch, **kwargs)
 
     default_target_branch = {
         'git': 'master',
         'hg': 'default'
     }.get(vcs)
 
     target_branch = target_branch or default_target_branch
 
     # PUSH it back
     stdout = stderr = None
     if vcs == 'hg':
         maybe_new_branch = ''
         if new_branch:
             maybe_new_branch = '--new-branch'
         stdout, stderr = Command(cwd).execute(
             'hg push --verbose {} -r {} {}'.format(maybe_new_branch, target_branch, clone_url)
         )
     elif vcs == 'git':
         stdout, stderr = Command(cwd).execute(
             """{} && 
             git push --verbose --tags {} {}""".format(git_ident, clone_url, target_branch)
         )
 
     return stdout, stderr
 
 
 def _check_proper_git_push(
         stdout, stderr, branch='master', should_set_default_branch=False):
     # Note: Git is writing most information to stderr intentionally
     assert 'fatal' not in stderr
     assert 'rejected' not in stderr
     assert 'Pushing to' in stderr
     assert '%s -> %s' % (branch, branch) in stderr
 
     if should_set_default_branch:
         assert "Setting default branch to %s" % branch in stderr
     else:
         assert "Setting default branch" not in stderr
 
 
 def _check_proper_hg_push(stdout, stderr, branch='default'):
     assert 'pushing to' in stdout
     assert 'searching for changes' in stdout
 
     assert 'abort:' not in stderr
 
 
 def _check_proper_clone(stdout, stderr, vcs):
     if vcs == 'hg':
         assert 'requesting all changes' in stdout
         assert 'adding changesets' in stdout
         assert 'adding manifests' in stdout
         assert 'adding file changes' in stdout
 
         assert stderr == ''
 
     if vcs == 'git':
         assert '' == stdout
         assert 'Cloning into' in stderr
         assert 'abort:' not in stderr
         assert 'fatal:' not in stderr