pytest: use consistent way of creating a fixture by using pytest.fixture()

rhodecode/api/tests/test_get_server_info.py

@@ -1,84 +1,84 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import pytest
 
 from rhodecode.model.scm import ScmModel
 from rhodecode.api.tests.utils import build_data, api_call, assert_ok
 
 
[e-mail]
[e-mail]()
 def http_host_stub():
     """
     To ensure that we can get an IP address, this test shall run with a
     hostname set to "localhost".
     """
     return 'localhost:80'
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetServerInfo(object):
     def test_api_get_server_info(self):
         id_, params = build_data(self.apikey, 'get_server_info')
         response = api_call(self.app, params)
         resp = response.json
         expected = ScmModel().get_server_info()
         expected['memory'] = resp['result']['memory']
         expected['uptime'] = resp['result']['uptime']
         expected['load'] = resp['result']['load']
         expected['cpu'] = resp['result']['cpu']
         expected['storage'] = resp['result']['storage']
         expected['storage_temp'] = resp['result']['storage_temp']
         expected['storage_inodes'] = resp['result']['storage_inodes']
         expected['server'] = resp['result']['server']
 
         expected['index_storage'] = resp['result']['index_storage']
         expected['storage'] = resp['result']['storage']
 
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_server_info_ip(self):
         id_, params = build_data(self.apikey, 'get_server_info')
         response = api_call(self.app, params)
         resp = response.json
         expected = ScmModel().get_server_info({'SERVER_NAME': 'unknown'})
         expected['memory'] = resp['result']['memory']
         expected['uptime'] = resp['result']['uptime']
         expected['load'] = resp['result']['load']
         expected['cpu'] = resp['result']['cpu']
         expected['storage'] = resp['result']['storage']
         expected['storage_temp'] = resp['result']['storage_temp']
         expected['storage_inodes'] = resp['result']['storage_inodes']
         expected['server'] = resp['result']['server']
 
         expected['index_storage'] = resp['result']['index_storage']
         expected['storage'] = resp['result']['storage']
 
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_server_info_data_for_search_index_build(self):
         id_, params = build_data(self.apikey, 'get_server_info')
         response = api_call(self.app, params)
         resp = response.json
 
         # required by indexer
         assert resp['result']['index_storage']
         assert resp['result']['storage']

rhodecode/apps/admin/tests/test_admin_settings.py

@@ -1,743 +1,743 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 import rhodecode
 from rhodecode.apps._base import ADMIN_PREFIX
 from rhodecode.lib.utils2 import md5
 from rhodecode.model.db import RhodeCodeUi
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel, IssueTrackerSettingsModel
 from rhodecode.tests import assert_session_flash
 from rhodecode.tests.utils import AssertResponse
 
 
 UPDATE_DATA_QUALNAME = 'rhodecode.model.update.UpdateModel.get_update_data'
 
 
 def route_path(name, params=None, **kwargs):
     import urllib
     from rhodecode.apps._base import ADMIN_PREFIX
 
     base_url = {
 
         'admin_settings':
             ADMIN_PREFIX +'/settings',
         'admin_settings_update':
             ADMIN_PREFIX + '/settings/update',
         'admin_settings_global':
             ADMIN_PREFIX + '/settings/global',
         'admin_settings_global_update':
             ADMIN_PREFIX + '/settings/global/update',
         'admin_settings_vcs':
             ADMIN_PREFIX + '/settings/vcs',
         'admin_settings_vcs_update':
             ADMIN_PREFIX + '/settings/vcs/update',
         'admin_settings_vcs_svn_pattern_delete':
             ADMIN_PREFIX + '/settings/vcs/svn_pattern_delete',
         'admin_settings_mapping':
             ADMIN_PREFIX + '/settings/mapping',
         'admin_settings_mapping_update':
             ADMIN_PREFIX + '/settings/mapping/update',
         'admin_settings_visual':
             ADMIN_PREFIX + '/settings/visual',
         'admin_settings_visual_update':
             ADMIN_PREFIX + '/settings/visual/update',
         'admin_settings_issuetracker':
             ADMIN_PREFIX + '/settings/issue-tracker',
         'admin_settings_issuetracker_update':
             ADMIN_PREFIX + '/settings/issue-tracker/update',
         'admin_settings_issuetracker_test':
             ADMIN_PREFIX + '/settings/issue-tracker/test',
         'admin_settings_issuetracker_delete':
             ADMIN_PREFIX + '/settings/issue-tracker/delete',
         'admin_settings_email':
             ADMIN_PREFIX + '/settings/email',
         'admin_settings_email_update':
             ADMIN_PREFIX + '/settings/email/update',
         'admin_settings_hooks':
             ADMIN_PREFIX + '/settings/hooks',
         'admin_settings_hooks_update':
             ADMIN_PREFIX + '/settings/hooks/update',
         'admin_settings_hooks_delete':
             ADMIN_PREFIX + '/settings/hooks/delete',
         'admin_settings_search':
             ADMIN_PREFIX + '/settings/search',
         'admin_settings_labs':
             ADMIN_PREFIX + '/settings/labs',
         'admin_settings_labs_update':
             ADMIN_PREFIX + '/settings/labs/update',
 
         'admin_settings_sessions':
             ADMIN_PREFIX + '/settings/sessions',
         'admin_settings_sessions_cleanup':
             ADMIN_PREFIX + '/settings/sessions/cleanup',
         'admin_settings_system':
             ADMIN_PREFIX + '/settings/system',
         'admin_settings_system_update':
             ADMIN_PREFIX + '/settings/system/updates',
         'admin_settings_open_source':
             ADMIN_PREFIX + '/settings/open_source',
 
 
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
     return base_url
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsController(object):
 
     @pytest.mark.parametrize('urlname', [
         'admin_settings_vcs',
         'admin_settings_mapping',
         'admin_settings_global',
         'admin_settings_visual',
         'admin_settings_email',
         'admin_settings_hooks',
         'admin_settings_search',
     ])
     def test_simple_get(self, urlname):
         self.app.get(route_path(urlname))
 
     def test_create_custom_hook(self, csrf_token):
         response = self.app.post(
             route_path('admin_settings_hooks_update'),
             params={
                 'new_hook_ui_key': 'test_hooks_1',
                 'new_hook_ui_value': 'cd /tmp',
                 'csrf_token': csrf_token})
 
         response = response.follow()
         response.mustcontain('test_hooks_1')
         response.mustcontain('cd /tmp')
 
     def test_create_custom_hook_delete(self, csrf_token):
         response = self.app.post(
             route_path('admin_settings_hooks_update'),
             params={
                 'new_hook_ui_key': 'test_hooks_2',
                 'new_hook_ui_value': 'cd /tmp2',
                 'csrf_token': csrf_token})
 
         response = response.follow()
         response.mustcontain('test_hooks_2')
         response.mustcontain('cd /tmp2')
 
         hook_id = SettingsModel().get_ui_by_key('test_hooks_2').ui_id
 
         # delete
         self.app.post(
             route_path('admin_settings_hooks_delete'),
             params={'hook_id': hook_id, 'csrf_token': csrf_token})
         response = self.app.get(route_path('admin_settings_hooks'))
         response.mustcontain(no=['test_hooks_2'])
         response.mustcontain(no=['cd /tmp2'])
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsGlobal(object):
 
     def test_pre_post_code_code_active(self, csrf_token):
         pre_code = 'rc-pre-code-187652122'
         post_code = 'rc-postcode-98165231'
 
         response = self.post_and_verify_settings({
             'rhodecode_pre_code': pre_code,
             'rhodecode_post_code': post_code,
             'csrf_token': csrf_token,
         })
 
         response = response.follow()
         response.mustcontain(pre_code, post_code)
 
     def test_pre_post_code_code_inactive(self, csrf_token):
         pre_code = 'rc-pre-code-187652122'
         post_code = 'rc-postcode-98165231'
         response = self.post_and_verify_settings({
             'rhodecode_pre_code': '',
             'rhodecode_post_code': '',
             'csrf_token': csrf_token,
         })
 
         response = response.follow()
         response.mustcontain(no=[pre_code, post_code])
 
     def test_captcha_activate(self, csrf_token):
         self.post_and_verify_settings({
             'rhodecode_captcha_private_key': '1234567890',
             'rhodecode_captcha_public_key': '1234567890',
             'csrf_token': csrf_token,
         })
 
         response = self.app.get(ADMIN_PREFIX + '/register')
         response.mustcontain('captcha')
 
     def test_captcha_deactivate(self, csrf_token):
         self.post_and_verify_settings({
             'rhodecode_captcha_private_key': '',
             'rhodecode_captcha_public_key': '1234567890',
             'csrf_token': csrf_token,
         })
 
         response = self.app.get(ADMIN_PREFIX + '/register')
         response.mustcontain(no=['captcha'])
 
     def test_title_change(self, csrf_token):
         old_title = 'RhodeCode'
 
         for new_title in ['Changed', 'Żółwik', old_title]:
             response = self.post_and_verify_settings({
                 'rhodecode_title': new_title,
                 'csrf_token': csrf_token,
             })
 
             response = response.follow()
             response.mustcontain(new_title)
 
     def post_and_verify_settings(self, settings):
         old_title = 'RhodeCode'
         old_realm = 'RhodeCode authentication'
         params = {
             'rhodecode_title': old_title,
             'rhodecode_realm': old_realm,
             'rhodecode_pre_code': '',
             'rhodecode_post_code': '',
             'rhodecode_captcha_private_key': '',
             'rhodecode_captcha_public_key': '',
             'rhodecode_create_personal_repo_group': False,
             'rhodecode_personal_repo_group_pattern': '${username}',
         }
         params.update(settings)
         response = self.app.post(
             route_path('admin_settings_global_update'), params=params)
 
         assert_session_flash(response, 'Updated application settings')
         app_settings = SettingsModel().get_all_settings()
         del settings['csrf_token']
         for key, value in settings.iteritems():
             assert app_settings[key] == value.decode('utf-8')
 
         return response
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestAdminSettingsVcs(object):
 
     def test_contains_svn_default_patterns(self):
         response = self.app.get(route_path('admin_settings_vcs'))
         expected_patterns = [
             '/trunk',
             '/branches/*',
             '/tags/*',
         ]
         for pattern in expected_patterns:
             response.mustcontain(pattern)
 
     def test_add_new_svn_branch_and_tag_pattern(
             self, backend_svn, form_defaults, disable_sql_cache,
             csrf_token):
         form_defaults.update({
             'new_svn_branch': '/exp/branches/*',
             'new_svn_tag': '/important_tags/*',
             'csrf_token': csrf_token,
         })
 
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults, status=302)
         response = response.follow()
 
         # Expect to find the new values on the page
         response.mustcontain('/exp/branches/*')
         response.mustcontain('/important_tags/*')
 
         # Expect that those patterns are used to match branches and tags now
         repo = backend_svn['svn-simple-layout'].scm_instance()
         assert 'exp/branches/exp-sphinx-docs' in repo.branches
         assert 'important_tags/v0.5' in repo.tags
 
     def test_add_same_svn_value_twice_shows_an_error_message(
             self, form_defaults, csrf_token, settings_util):
         settings_util.create_rhodecode_ui('vcs_svn_branch', '/test')
         settings_util.create_rhodecode_ui('vcs_svn_tag', '/test')
 
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params={
                 'paths_root_path': form_defaults['paths_root_path'],
                 'new_svn_branch': '/test',
                 'new_svn_tag': '/test',
                 'csrf_token': csrf_token,
             },
             status=200)
 
         response.mustcontain("Pattern already exists")
         response.mustcontain("Some form inputs contain invalid data.")
 
     @pytest.mark.parametrize('section', [
         'vcs_svn_branch',
         'vcs_svn_tag',
     ])
     def test_delete_svn_patterns(
             self, section, csrf_token, settings_util):
         setting = settings_util.create_rhodecode_ui(
             section, '/test_delete', cleanup=False)
 
         self.app.post(
             route_path('admin_settings_vcs_svn_pattern_delete'),
             params={
                 'delete_svn_pattern': setting.ui_id,
                 'csrf_token': csrf_token},
             headers={'X-REQUESTED-WITH': 'XMLHttpRequest'})
 
     @pytest.mark.parametrize('section', [
         'vcs_svn_branch',
         'vcs_svn_tag',
     ])
     def test_delete_svn_patterns_raises_404_when_no_xhr(
             self, section, csrf_token, settings_util):
         setting = settings_util.create_rhodecode_ui(section, '/test_delete')
 
         self.app.post(
             route_path('admin_settings_vcs_svn_pattern_delete'),
             params={
                 'delete_svn_pattern': setting.ui_id,
                 'csrf_token': csrf_token},
             status=404)
 
     def test_extensions_hgsubversion(self, form_defaults, csrf_token):
         form_defaults.update({
             'csrf_token': csrf_token,
             'extensions_hgsubversion': 'True',
         })
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
 
         response = response.follow()
         extensions_input = (
             '<input id="extensions_hgsubversion" '
             'name="extensions_hgsubversion" type="checkbox" '
             'value="True" checked="checked" />')
         response.mustcontain(extensions_input)
 
     def test_extensions_hgevolve(self, form_defaults, csrf_token):
         form_defaults.update({
             'csrf_token': csrf_token,
             'extensions_evolve': 'True',
         })
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
 
         response = response.follow()
         extensions_input = (
             '<input id="extensions_evolve" '
             'name="extensions_evolve" type="checkbox" '
             'value="True" checked="checked" />')
         response.mustcontain(extensions_input)
 
     def test_has_a_section_for_pull_request_settings(self):
         response = self.app.get(route_path('admin_settings_vcs'))
         response.mustcontain('Pull Request Settings')
 
     def test_has_an_input_for_invalidation_of_inline_comments(self):
         response = self.app.get(route_path('admin_settings_vcs'))
         assert_response = AssertResponse(response)
         assert_response.one_element_exists(
             '[name=rhodecode_use_outdated_comments]')
 
     @pytest.mark.parametrize('new_value', [True, False])
     def test_allows_to_change_invalidation_of_inline_comments(
             self, form_defaults, csrf_token, new_value):
         setting_key = 'use_outdated_comments'
         setting = SettingsModel().create_or_update_setting(
             setting_key, not new_value, 'bool')
         Session().add(setting)
         Session().commit()
 
         form_defaults.update({
             'csrf_token': csrf_token,
             'rhodecode_use_outdated_comments': str(new_value),
         })
         response = self.app.post(
             route_path('admin_settings_vcs_update'),
             params=form_defaults,
             status=302)
         response = response.follow()
         setting = SettingsModel().get_setting_by_name(setting_key)
         assert setting.app_settings_value is new_value
 
     @pytest.mark.parametrize('new_value', [True, False])
     def test_allows_to_change_hg_rebase_merge_strategy(
             self, form_defaults, csrf_token, new_value):
         setting_key = 'hg_use_rebase_for_merging'
 
         form_defaults.update({
             'csrf_token': csrf_token,
             'rhodecode_' + setting_key: str(new_value),
         })
 
         with mock.patch.dict(
                 rhodecode.CONFIG, {'labs_settings_active': 'true'}):
             self.app.post(
                 route_path('admin_settings_vcs_update'),
                 params=form_defaults,
                 status=302)
 
         setting = SettingsModel().get_setting_by_name(setting_key)
         assert setting.app_settings_value is new_value
 
-    @pytest.fixture
+    @pytest.fixture()
     def disable_sql_cache(self, request):
         patcher = mock.patch(
             'rhodecode.lib.caching_query.FromCache.process_query')
         request.addfinalizer(patcher.stop)
         patcher.start()
 
-    @pytest.fixture
+    @pytest.fixture()
     def form_defaults(self):
         from rhodecode.apps.admin.views.settings import AdminSettingsView
         return AdminSettingsView._form_defaults()
 
     # TODO: johbo: What we really want is to checkpoint before a test run and
     # reset the session afterwards.
     @pytest.fixture(scope='class', autouse=True)
     def cleanup_settings(self, request, baseapp):
         ui_id = RhodeCodeUi.ui_id
         original_ids = list(
             r.ui_id for r in RhodeCodeUi.query().values(ui_id))
 
         @request.addfinalizer
         def cleanup():
             RhodeCodeUi.query().filter(
                 ui_id.notin_(original_ids)).delete(False)
 
 
 @pytest.mark.usefixtures('autologin_user', 'app')
 class TestLabsSettings(object):
     def test_get_settings_page_disabled(self):
         with mock.patch.dict(
                 rhodecode.CONFIG, {'labs_settings_active': 'false'}):
 
             response = self.app.get(
                 route_path('admin_settings_labs'), status=302)
 
         assert response.location.endswith(route_path('admin_settings'))
 
     def test_get_settings_page_enabled(self):
         from rhodecode.apps.admin.views import settings
         lab_settings = [
             settings.LabSetting(
                 key='rhodecode_bool',
                 type='bool',
                 group='bool group',
                 label='bool label',
                 help='bool help'
             ),
             settings.LabSetting(
                 key='rhodecode_text',
                 type='unicode',
                 group='text group',
                 label='text label',
                 help='text help'
             ),
         ]
         with mock.patch.dict(rhodecode.CONFIG,
                              {'labs_settings_active': 'true'}):
             with mock.patch.object(settings, '_LAB_SETTINGS', lab_settings):
                 response = self.app.get(route_path('admin_settings_labs'))
 
         assert '<label>bool group:</label>' in response
         assert '<label for="rhodecode_bool">bool label</label>' in response
         assert '<p class="help-block">bool help</p>' in response
         assert 'name="rhodecode_bool" type="checkbox"' in response
 
         assert '<label>text group:</label>' in response
         assert '<label for="rhodecode_text">text label</label>' in response
         assert '<p class="help-block">text help</p>' in response
         assert 'name="rhodecode_text" size="60" type="text"' in response
 
 
 @pytest.mark.usefixtures('app')
 class TestOpenSourceLicenses(object):
 
     def test_records_are_displayed(self, autologin_user):
         sample_licenses = [
             {
                 "license": [
                     {
                         "fullName": "BSD 4-clause \"Original\" or \"Old\" License",
                         "shortName": "bsdOriginal",
                         "spdxId": "BSD-4-Clause",
                         "url": "http://spdx.org/licenses/BSD-4-Clause.html"
                     }
                 ],
                 "name": "python2.7-coverage-3.7.1"
             },
             {
                 "license": [
                     {
                         "fullName": "MIT License",
                         "shortName": "mit",
                         "spdxId": "MIT",
                         "url": "http://spdx.org/licenses/MIT.html"
                     }
                 ],
                 "name": "python2.7-bootstrapped-pip-9.0.1"
             },
         ]
         read_licenses_patch = mock.patch(
             'rhodecode.apps.admin.views.open_source_licenses.read_opensource_licenses',
             return_value=sample_licenses)
         with read_licenses_patch:
             response = self.app.get(
                 route_path('admin_settings_open_source'), status=200)
 
         assert_response = AssertResponse(response)
         assert_response.element_contains(
             '.panel-heading', 'Licenses of Third Party Packages')
         for license_data in sample_licenses:
             response.mustcontain(license_data["license"][0]["spdxId"])
             assert_response.element_contains('.panel-body', license_data["name"])
 
     def test_records_can_be_read(self, autologin_user):
         response = self.app.get(
             route_path('admin_settings_open_source'), status=200)
         assert_response = AssertResponse(response)
         assert_response.element_contains(
             '.panel-heading', 'Licenses of Third Party Packages')
 
     def test_forbidden_when_normal_user(self, autologin_regular_user):
         self.app.get(
             route_path('admin_settings_open_source'), status=404)
 
 
 @pytest.mark.usefixtures('app')
 class TestUserSessions(object):
 
     def test_forbidden_when_normal_user(self, autologin_regular_user):
         self.app.get(route_path('admin_settings_sessions'), status=404)
 
     def test_show_sessions_page(self, autologin_user):
         response = self.app.get(route_path('admin_settings_sessions'), status=200)
         response.mustcontain('file')
 
     def test_cleanup_old_sessions(self, autologin_user, csrf_token):
 
         post_data = {
             'csrf_token': csrf_token,
             'expire_days': '60'
         }
         response = self.app.post(
             route_path('admin_settings_sessions_cleanup'), params=post_data,
             status=302)
         assert_session_flash(response, 'Cleaned up old sessions')
 
 
 @pytest.mark.usefixtures('app')
 class TestAdminSystemInfo(object):
 
     def test_forbidden_when_normal_user(self, autologin_regular_user):
         self.app.get(route_path('admin_settings_system'), status=404)
 
     def test_system_info_page(self, autologin_user):
         response = self.app.get(route_path('admin_settings_system'))
         response.mustcontain('RhodeCode Community Edition, version {}'.format(
             rhodecode.__version__))
 
     def test_system_update_new_version(self, autologin_user):
         update_data = {
             'versions': [
                 {
                     'version': '100.3.1415926535',
                     'general': 'The latest version we are ever going to ship'
                 },
                 {
                     'version': '0.0.0',
                     'general': 'The first version we ever shipped'
                 }
             ]
         }
         with mock.patch(UPDATE_DATA_QUALNAME, return_value=update_data):
             response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain('A <b>new version</b> is available')
 
     def test_system_update_nothing_new(self, autologin_user):
         update_data = {
             'versions': [
                 {
                     'version': '0.0.0',
                     'general': 'The first version we ever shipped'
                 }
             ]
         }
         with mock.patch(UPDATE_DATA_QUALNAME, return_value=update_data):
             response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain(
                 'This instance is already running the <b>latest</b> stable version')
 
     def test_system_update_bad_response(self, autologin_user):
         with mock.patch(UPDATE_DATA_QUALNAME, side_effect=ValueError('foo')):
             response = self.app.get(route_path('admin_settings_system_update'))
             response.mustcontain(
                 'Bad data sent from update server')
 
 
 @pytest.mark.usefixtures("app")
 class TestAdminSettingsIssueTracker(object):
     RC_PREFIX = 'rhodecode_'
     SHORT_PATTERN_KEY = 'issuetracker_pat_'
     PATTERN_KEY = RC_PREFIX + SHORT_PATTERN_KEY
 
     def test_issuetracker_index(self, autologin_user):
         response = self.app.get(route_path('admin_settings_issuetracker'))
         assert response.status_code == 200
 
     def test_add_empty_issuetracker_pattern(
             self, request, autologin_user, csrf_token):
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
 
     def test_add_issuetracker_pattern(
             self, request, autologin_user, csrf_token):
         pattern = 'issuetracker_pat'
         another_pattern = pattern+'1'
         post_url = route_path('admin_settings_issuetracker_update')
         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': 'https://url1',
             'new_pattern_prefix_1': 'prefix1',
             'new_pattern_description_1': 'description1',
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         self.uid = md5(pattern)
         assert settings[self.PATTERN_KEY+self.uid] == pattern
         self.another_uid = md5(another_pattern)
         assert settings[self.PATTERN_KEY+self.another_uid] == another_pattern
 
         @request.addfinalizer
         def cleanup():
             defaults = SettingsModel().get_all_settings()
 
             entries = [name for name in defaults if (
                 (self.uid in name) or (self.another_uid) in name)]
             start = len(self.RC_PREFIX)
             for del_key in entries:
                 # TODO: anderson: get_by_name needs name without prefix
                 entry = SettingsModel().get_setting_by_name(del_key[start:])
                 Session().delete(entry)
 
             Session().commit()
 
     def test_edit_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, request):
         old_pattern = 'issuetracker_pat'
         old_uid = md5(old_pattern)
         pattern = 'issuetracker_pat_new'
         self.new_uid = md5(pattern)
 
         SettingsModel().create_or_update_setting(
             self.SHORT_PATTERN_KEY+old_uid, old_pattern, 'unicode')
 
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'https://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)
         settings = SettingsModel().get_all_settings()
         assert settings[self.PATTERN_KEY+self.new_uid] == pattern
         assert self.PATTERN_KEY+old_uid not in settings
 
         @request.addfinalizer
         def cleanup():
             IssueTrackerSettingsModel().delete_entries(self.new_uid)
 
     def test_replace_issuetracker_pattern_description(
             self, autologin_user, csrf_token, request, settings_util):
         prefix = 'issuetracker'
         pattern = 'issuetracker_pat'
         self.uid = md5(pattern)
         pattern_key = '_'.join([prefix, 'pat', self.uid])
         rc_pattern_key = '_'.join(['rhodecode', pattern_key])
         desc_key = '_'.join([prefix, 'desc', self.uid])
         rc_desc_key = '_'.join(['rhodecode', desc_key])
         new_description = 'new_description'
 
         settings_util.create_rhodecode_setting(
             pattern_key, pattern, 'unicode', cleanup=False)
         settings_util.create_rhodecode_setting(
             desc_key, 'old description', 'unicode', cleanup=False)
 
         post_url = route_path('admin_settings_issuetracker_update')
         post_data = {
             'new_pattern_pattern_0': pattern,
             'new_pattern_url_0': 'https://url',
             'new_pattern_prefix_0': 'prefix',
             'new_pattern_description_0': new_description,
             'uid': self.uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         assert settings[rc_pattern_key] == pattern
         assert settings[rc_desc_key] == new_description
 
         @request.addfinalizer
         def cleanup():
             IssueTrackerSettingsModel().delete_entries(self.uid)
 
     def test_delete_issuetracker_pattern(
             self, autologin_user, backend, csrf_token, settings_util):
         pattern = 'issuetracker_pat'
         uid = md5(pattern)
         settings_util.create_rhodecode_setting(
             self.SHORT_PATTERN_KEY+uid, pattern, 'unicode', cleanup=False)
 
         post_url = route_path('admin_settings_issuetracker_delete')
         post_data = {
             '_method': 'delete',
             'uid': uid,
             'csrf_token': csrf_token
         }
         self.app.post(post_url, post_data, status=302)
         settings = SettingsModel().get_all_settings()
         assert 'rhodecode_%s%s' % (self.SHORT_PATTERN_KEY, uid) not in settings

rhodecode/apps/gist/tests/test_admin_gists.py

@@ -1,391 +1,391 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 from rhodecode.lib import helpers as h
 from rhodecode.model.db import User, Gist
 from rhodecode.model.gist import GistModel
 from rhodecode.model.meta import Session
 from rhodecode.tests import (
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,
     TestController, assert_session_flash)
 
 
 def route_path(name, params=None, **kwargs):
     import urllib
     from rhodecode.apps._base import ADMIN_PREFIX
 
     base_url = {
         'gists_show': ADMIN_PREFIX + '/gists',
         'gists_new': ADMIN_PREFIX + '/gists/new',
         'gists_create': ADMIN_PREFIX + '/gists/create',
         'gist_show': ADMIN_PREFIX + '/gists/{gist_id}',
         'gist_delete': ADMIN_PREFIX + '/gists/{gist_id}/delete',
         'gist_edit': ADMIN_PREFIX + '/gists/{gist_id}/edit',
         'gist_edit_check_revision': ADMIN_PREFIX + '/gists/{gist_id}/edit/check_revision',
         'gist_update': ADMIN_PREFIX + '/gists/{gist_id}/update',
         'gist_show_rev': ADMIN_PREFIX + '/gists/{gist_id}/{revision}',
         'gist_show_formatted': ADMIN_PREFIX + '/gists/{gist_id}/{revision}/{format}',
         'gist_show_formatted_path': ADMIN_PREFIX + '/gists/{gist_id}/{revision}/{format}/{f_path}',
 
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
     return base_url
 
 
 class GistUtility(object):
 
     def __init__(self):
         self._gist_ids = []
 
     def __call__(
             self, f_name, content='some gist', lifetime=-1,
             description='gist-desc', gist_type='public',
             acl_level=Gist.GIST_PUBLIC, owner=TEST_USER_ADMIN_LOGIN):
         gist_mapping = {
             f_name: {'content': content}
         }
         user = User.get_by_username(owner)
         gist = GistModel().create(
             description, owner=user, gist_mapping=gist_mapping,
             gist_type=gist_type, lifetime=lifetime, gist_acl_level=acl_level)
         Session().commit()
         self._gist_ids.append(gist.gist_id)
         return gist
 
     def cleanup(self):
         for gist_id in self._gist_ids:
             gist = Gist.get(gist_id)
             if gist:
                 Session().delete(gist)
 
         Session().commit()
 
 
[e-mail]
[e-mail]()
 def create_gist(request):
     gist_utility = GistUtility()
     request.addfinalizer(gist_utility.cleanup)
     return gist_utility
 
 
 class TestGistsController(TestController):
 
     def test_index_empty(self, create_gist):
         self.log_user()
         response = self.app.get(route_path('gists_show'))
         response.mustcontain('data: [],')
 
     def test_index(self, create_gist):
         self.log_user()
         g1 = create_gist('gist1')
         g2 = create_gist('gist2', lifetime=1400)
         g3 = create_gist('gist3', description='gist3-desc')
         g4 = create_gist('gist4', gist_type='private').gist_access_id
         response = self.app.get(route_path('gists_show'))
 
         response.mustcontain('gist: %s' % g1.gist_access_id)
         response.mustcontain('gist: %s' % g2.gist_access_id)
         response.mustcontain('gist: %s' % g3.gist_access_id)
         response.mustcontain('gist3-desc')
         response.mustcontain(no=['gist: %s' % g4])
 
         # Expiration information should be visible
         expires_tag = '%s' % h.age_component(
             h.time_to_utcdatetime(g2.gist_expires))
         response.mustcontain(expires_tag.replace('"', '\\"'))
 
     def test_index_private_gists(self, create_gist):
         self.log_user()
         gist = create_gist('gist5', gist_type='private')
         response = self.app.get(route_path('gists_show', params=dict(private=1)))
 
         # and privates
         response.mustcontain('gist: %s' % gist.gist_access_id)
 
     def test_index_show_all(self, create_gist):
         self.log_user()
         create_gist('gist1')
         create_gist('gist2', lifetime=1400)
         create_gist('gist3', description='gist3-desc')
         create_gist('gist4', gist_type='private')
 
         response = self.app.get(route_path('gists_show', params=dict(all=1)))
 
         assert len(GistModel.get_all()) == 4
         # and privates
         for gist in GistModel.get_all():
             response.mustcontain('gist: %s' % gist.gist_access_id)
 
     def test_index_show_all_hidden_from_regular(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         create_gist('gist2', gist_type='private')
         create_gist('gist3', gist_type='private')
         create_gist('gist4', gist_type='private')
 
         response = self.app.get(route_path('gists_show', params=dict(all=1)))
 
         assert len(GistModel.get_all()) == 3
         # since we don't have access to private in this view, we
         # should see nothing
         for gist in GistModel.get_all():
             response.mustcontain(no=['gist: %s' % gist.gist_access_id])
 
     def test_create(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'gist test',
                     'filename': 'foo',
                     'public': 'public',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
             status=302)
         response = response.follow()
         response.mustcontain('added file: foo')
         response.mustcontain('gist test')
 
     def test_create_with_path_with_dirs(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'gist test',
                     'filename': '/home/foo',
                     'public': 'public',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
             status=200)
         response.mustcontain('Filename /home/foo cannot be inside a directory')
 
     def test_access_expired_gist(self, create_gist):
         self.log_user()
         gist = create_gist('never-see-me')
         gist.gist_expires = 0  # 1970
         Session().add(gist)
         Session().commit()
 
         self.app.get(route_path('gist_show', gist_id=gist.gist_access_id),
                      status=404)
 
     def test_create_private(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'private gist test',
                     'filename': 'private-foo',
                     'private': 'private',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
             status=302)
         response = response.follow()
         response.mustcontain('added file: private-foo<')
         response.mustcontain('private gist test')
         response.mustcontain('Private Gist')
         # Make sure private gists are not indexed by robots
         response.mustcontain(
             '<meta name="robots" content="noindex, nofollow">')
 
     def test_create_private_acl_private(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'private gist test',
                     'filename': 'private-foo',
                     'private': 'private',
                     'gist_acl_level': Gist.ACL_LEVEL_PRIVATE,
                     'csrf_token': self.csrf_token},
             status=302)
         response = response.follow()
         response.mustcontain('added file: private-foo<')
         response.mustcontain('private gist test')
         response.mustcontain('Private Gist')
         # Make sure private gists are not indexed by robots
         response.mustcontain(
             '<meta name="robots" content="noindex, nofollow">')
 
     def test_create_with_description(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'gist test',
                     'filename': 'foo-desc',
                     'description': 'gist-desc',
                     'public': 'public',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
              status=302)
         response = response.follow()
         response.mustcontain('added file: foo-desc')
         response.mustcontain('gist test')
         response.mustcontain('gist-desc')
 
     def test_create_public_with_anonymous_access(self):
         self.log_user()
         params = {
             'lifetime': -1,
             'content': 'gist test',
             'filename': 'foo-desc',
             'description': 'gist-desc',
             'public': 'public',
             'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
             'csrf_token': self.csrf_token
         }
         response = self.app.post(
             route_path('gists_create'), params=params, status=302)
         self.logout_user()
         response = response.follow()
         response.mustcontain('added file: foo-desc')
         response.mustcontain('gist test')
         response.mustcontain('gist-desc')
 
     def test_new(self):
         self.log_user()
         self.app.get(route_path('gists_new'))
 
     def test_delete(self, create_gist):
         self.log_user()
         gist = create_gist('delete-me')
         response = self.app.post(
             route_path('gist_delete', gist_id=gist.gist_id),
             params={'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Deleted gist %s' % gist.gist_id)
 
     def test_delete_normal_user_his_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist('delete-me', owner=TEST_USER_REGULAR_LOGIN)
 
         response = self.app.post(
             route_path('gist_delete', gist_id=gist.gist_id),
             params={'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Deleted gist %s' % gist.gist_id)
 
     def test_delete_normal_user_not_his_own_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist('delete-me-2')
 
         self.app.post(
             route_path('gist_delete', gist_id=gist.gist_id),
             params={'csrf_token': self.csrf_token}, status=404)
 
     def test_show(self, create_gist):
         gist = create_gist('gist-show-me')
         response = self.app.get(route_path('gist_show', gist_id=gist.gist_access_id))
 
         response.mustcontain('added file: gist-show-me<')
 
         assert_response = response.assert_response()
         assert_response.element_equals_to(
             'div.rc-user span.user',
             '<a href="/_profiles/test_admin">test_admin</a></span>')
 
         response.mustcontain('gist-desc')
 
     def test_show_without_hg(self, create_gist):
         with mock.patch(
                 'rhodecode.lib.vcs.settings.ALIASES', ['git']):
             gist = create_gist('gist-show-me-again')
             self.app.get(
                 route_path('gist_show', gist_id=gist.gist_access_id), status=200)
 
     def test_show_acl_private(self, create_gist):
         gist = create_gist('gist-show-me-only-when-im-logged-in',
                            acl_level=Gist.ACL_LEVEL_PRIVATE)
         self.app.get(
             route_path('gist_show', gist_id=gist.gist_access_id), status=404)
 
         # now we log-in we should see thi gist
         self.log_user()
         response = self.app.get(
             route_path('gist_show', gist_id=gist.gist_access_id))
         response.mustcontain('added file: gist-show-me-only-when-im-logged-in')
 
         assert_response = response.assert_response()
         assert_response.element_equals_to(
             'div.rc-user span.user',
             '<a href="/_profiles/test_admin">test_admin</a></span>')
         response.mustcontain('gist-desc')
 
     def test_show_as_raw(self, create_gist):
         gist = create_gist('gist-show-me', content='GIST CONTENT')
         response = self.app.get(
             route_path('gist_show_formatted',
                        gist_id=gist.gist_access_id, revision='tip',
                        format='raw'))
         assert response.body == 'GIST CONTENT'
 
     def test_show_as_raw_individual_file(self, create_gist):
         gist = create_gist('gist-show-me-raw', content='GIST BODY')
         response = self.app.get(
             route_path('gist_show_formatted_path',
                        gist_id=gist.gist_access_id, format='raw',
                        revision='tip', f_path='gist-show-me-raw'))
         assert response.body == 'GIST BODY'
 
     def test_edit_page(self, create_gist):
         self.log_user()
         gist = create_gist('gist-for-edit', content='GIST EDIT BODY')
         response = self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id))
         response.mustcontain('GIST EDIT BODY')
 
     def test_edit_page_non_logged_user(self, create_gist):
         gist = create_gist('gist-for-edit', content='GIST EDIT BODY')
         self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id),
                      status=302)
 
     def test_edit_normal_user_his_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist('gist-for-edit', owner=TEST_USER_REGULAR_LOGIN)
         self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id,
                                 status=200))
 
     def test_edit_normal_user_not_his_own_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist('delete-me')
         self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id),
                      status=404)
 
     def test_user_first_name_is_escaped(self, user_util, create_gist):
         xss_atack_string = '"><script>alert(\'First Name\')</script>'
         xss_escaped_string = h.html_escape(h.escape(xss_atack_string))
         password = 'test'
         user = user_util.create_user(
             firstname=xss_atack_string, password=password)
         create_gist('gist', gist_type='public', owner=user.username)
         response = self.app.get(route_path('gists_show'))
         response.mustcontain(xss_escaped_string)
 
     def test_user_last_name_is_escaped(self, user_util, create_gist):
         xss_atack_string = '"><script>alert(\'Last Name\')</script>'
         xss_escaped_string = h.html_escape(h.escape(xss_atack_string))
         password = 'test'
         user = user_util.create_user(
             lastname=xss_atack_string, password=password)
         create_gist('gist', gist_type='public', owner=user.username)
         response = self.app.get(route_path('gists_show'))
         response.mustcontain(xss_escaped_string)

rhodecode/apps/repository/tests/test_repo_summary.py

@@ -1,524 +1,524 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import re
 
 import mock
 import pytest
 
 from rhodecode.apps.repository.views.repo_summary import RepoSummaryView
 from rhodecode.lib import helpers as h
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.utils2 import AttributeDict, safe_str
 from rhodecode.lib.vcs.exceptions import RepositoryRequirementError
 from rhodecode.model.db import Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import ScmModel
 from rhodecode.tests import assert_session_flash
 from rhodecode.tests.fixture import Fixture
 from rhodecode.tests.utils import AssertResponse, repo_on_filesystem
 
 
 fixture = Fixture()
 
 
 def route_path(name, params=None, **kwargs):
     import urllib
 
     base_url = {
         'repo_summary': '/{repo_name}',
         'repo_stats': '/{repo_name}/repo_stats/{commit_id}',
         'repo_refs_data': '/{repo_name}/refs-data',
         'repo_refs_changelog_data': '/{repo_name}/refs-data-changelog',
         'repo_creating_check': '/{repo_name}/repo_creating_check',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
     return base_url
 
 
 def assert_clone_url(response, server, repo, disabled=False):
 
     response.mustcontain(
         '<input type="text" class="input-monospace clone_url_input" '
         '{disabled}readonly="readonly" '
         'value="http://test_admin@{server}/{repo}"/>'.format(
             server=server, repo=repo, disabled='disabled ' if disabled else ' ')
     )
 
 
 @pytest.mark.usefixtures('app')
 class TestSummaryView(object):
     def test_index(self, autologin_user, backend, http_host_only_stub):
         repo_id = backend.repo.repo_id
         repo_name = backend.repo_name
         with mock.patch('rhodecode.lib.helpers.is_svn_without_proxy',
                         return_value=False):
             response = self.app.get(
                 route_path('repo_summary', repo_name=repo_name))
 
         # repo type
         response.mustcontain(
             '<i class="icon-%s">' % (backend.alias, )
         )
         # public/private
         response.mustcontain(
             """<i class="icon-unlock-alt">"""
         )
 
         # clone url...
         assert_clone_url(response, http_host_only_stub, repo_name)
         assert_clone_url(response, http_host_only_stub, '_{}'.format(repo_id))
 
     def test_index_svn_without_proxy(
             self, autologin_user, backend_svn, http_host_only_stub):
         repo_id = backend_svn.repo.repo_id
         repo_name = backend_svn.repo_name
         response = self.app.get(route_path('repo_summary', repo_name=repo_name))
         # clone url...
 
         assert_clone_url(response, http_host_only_stub, repo_name, disabled=True)
         assert_clone_url(response, http_host_only_stub, '_{}'.format(repo_id), disabled=True)
 
     def test_index_with_trailing_slash(
             self, autologin_user, backend, http_host_only_stub):
 
         repo_id = backend.repo.repo_id
         repo_name = backend.repo_name
         with mock.patch('rhodecode.lib.helpers.is_svn_without_proxy',
                         return_value=False):
             response = self.app.get(
                 route_path('repo_summary', repo_name=repo_name) + '/',
                 status=200)
 
         # clone url...
         assert_clone_url(response, http_host_only_stub, repo_name)
         assert_clone_url(response, http_host_only_stub, '_{}'.format(repo_id))
 
     def test_index_by_id(self, autologin_user, backend):
         repo_id = backend.repo.repo_id
         response = self.app.get(
             route_path('repo_summary', repo_name='_%s' % (repo_id,)))
 
         # repo type
         response.mustcontain(
             '<i class="icon-%s">' % (backend.alias, )
         )
         # public/private
         response.mustcontain(
             """<i class="icon-unlock-alt">"""
         )
 
     def test_index_by_repo_having_id_path_in_name_hg(self, autologin_user):
         fixture.create_repo(name='repo_1')
         response = self.app.get(route_path('repo_summary', repo_name='repo_1'))
 
         try:
             response.mustcontain("repo_1")
         finally:
             RepoModel().delete(Repository.get_by_repo_name('repo_1'))
             Session().commit()
 
     def test_index_with_anonymous_access_disabled(
             self, backend, disable_anonymous_user):
         response = self.app.get(
             route_path('repo_summary', repo_name=backend.repo_name), status=302)
         assert 'login' in response.location
 
     def _enable_stats(self, repo):
         r = Repository.get_by_repo_name(repo)
         r.enable_statistics = True
         Session().add(r)
         Session().commit()
 
     expected_trending = {
         'hg': {
             "py": {"count": 68, "desc": ["Python"]},
             "rst": {"count": 16, "desc": ["Rst"]},
             "css": {"count": 2, "desc": ["Css"]},
             "sh": {"count": 2, "desc": ["Bash"]},
             "bat": {"count": 1, "desc": ["Batch"]},
             "cfg": {"count": 1, "desc": ["Ini"]},
             "html": {"count": 1, "desc": ["EvoqueHtml", "Html"]},
             "ini": {"count": 1, "desc": ["Ini"]},
             "js": {"count": 1, "desc": ["Javascript"]},
             "makefile": {"count": 1, "desc": ["Makefile", "Makefile"]}
         },
         'git': {
             "py": {"count": 68, "desc": ["Python"]},
             "rst": {"count": 16, "desc": ["Rst"]},
             "css": {"count": 2, "desc": ["Css"]},
             "sh": {"count": 2, "desc": ["Bash"]},
             "bat": {"count": 1, "desc": ["Batch"]},
             "cfg": {"count": 1, "desc": ["Ini"]},
             "html": {"count": 1, "desc": ["EvoqueHtml", "Html"]},
             "ini": {"count": 1, "desc": ["Ini"]},
             "js": {"count": 1, "desc": ["Javascript"]},
             "makefile": {"count": 1, "desc": ["Makefile", "Makefile"]}
         },
         'svn': {
             "py": {"count": 75, "desc": ["Python"]},
             "rst": {"count": 16, "desc": ["Rst"]},
             "html": {"count": 11, "desc": ["EvoqueHtml", "Html"]},
             "css": {"count": 2, "desc": ["Css"]},
             "bat": {"count": 1, "desc": ["Batch"]},
             "cfg": {"count": 1, "desc": ["Ini"]},
             "ini": {"count": 1, "desc": ["Ini"]},
             "js": {"count": 1, "desc": ["Javascript"]},
             "makefile": {"count": 1, "desc": ["Makefile", "Makefile"]},
             "sh": {"count": 1, "desc": ["Bash"]}
         },
     }
 
     def test_repo_stats(self, autologin_user, backend, xhr_header):
         response = self.app.get(
             route_path(
                 'repo_stats', repo_name=backend.repo_name, commit_id='tip'),
             extra_environ=xhr_header,
             status=200)
         assert re.match(r'6[\d\.]+ KiB', response.json['size'])
 
     def test_repo_stats_code_stats_enabled(self, autologin_user, backend, xhr_header):
         repo_name = backend.repo_name
 
         # codes stats
         self._enable_stats(repo_name)
         ScmModel().mark_for_invalidation(repo_name)
 
         response = self.app.get(
             route_path(
                 'repo_stats', repo_name=backend.repo_name, commit_id='tip'),
             extra_environ=xhr_header,
             status=200)
 
         expected_data = self.expected_trending[backend.alias]
         returned_stats = response.json['code_stats']
         for k, v in expected_data.items():
             assert v == returned_stats[k]
 
     def test_repo_refs_data(self, backend):
         response = self.app.get(
             route_path('repo_refs_data', repo_name=backend.repo_name),
             status=200)
 
         # Ensure that there is the correct amount of items in the result
         repo = backend.repo.scm_instance()
         data = response.json['results']
         items = sum(len(section['children']) for section in data)
         repo_refs = len(repo.branches) + len(repo.tags) + len(repo.bookmarks)
         assert items == repo_refs
 
     def test_index_shows_missing_requirements_message(
             self, backend, autologin_user):
         repo_name = backend.repo_name
         scm_patcher = mock.patch.object(
             Repository, 'scm_instance', side_effect=RepositoryRequirementError)
 
         with scm_patcher:
             response = self.app.get(
                 route_path('repo_summary', repo_name=repo_name))
         assert_response = AssertResponse(response)
         assert_response.element_contains(
             '.main .alert-warning strong', 'Missing requirements')
         assert_response.element_contains(
             '.main .alert-warning',
             'Commits cannot be displayed, because this repository '
             'uses one or more extensions, which was not enabled.')
 
     def test_missing_requirements_page_does_not_contains_switch_to(
             self, autologin_user, backend):
         repo_name = backend.repo_name
         scm_patcher = mock.patch.object(
             Repository, 'scm_instance', side_effect=RepositoryRequirementError)
 
         with scm_patcher:
             response = self.app.get(route_path('repo_summary', repo_name=repo_name))
         response.mustcontain(no='Switch To')
 
 
 @pytest.mark.usefixtures('app')
 class TestRepoLocation(object):
 
     @pytest.mark.parametrize("suffix", [u'', u'ąęł'], ids=['', 'non-ascii'])
     def test_missing_filesystem_repo(
             self, autologin_user, backend, suffix, csrf_token):
         repo = backend.create_repo(name_suffix=suffix)
         repo_name = repo.repo_name
 
         # delete from file system
         RepoModel()._delete_filesystem_repo(repo)
 
         # test if the repo is still in the database
         new_repo = RepoModel().get_by_repo_name(repo_name)
         assert new_repo.repo_name == repo_name
 
         # check if repo is not in the filesystem
         assert not repo_on_filesystem(repo_name)
 
         response = self.app.get(
             route_path('repo_summary', repo_name=safe_str(repo_name)), status=302)
 
         msg = 'The repository `%s` cannot be loaded in filesystem. ' \
               'Please check if it exist, or is not damaged.' % repo_name
         assert_session_flash(response, msg)
 
     @pytest.mark.parametrize("suffix", [u'', u'ąęł'], ids=['', 'non-ascii'])
     def test_missing_filesystem_repo_on_repo_check(
             self, autologin_user, backend, suffix, csrf_token):
         repo = backend.create_repo(name_suffix=suffix)
         repo_name = repo.repo_name
 
         # delete from file system
         RepoModel()._delete_filesystem_repo(repo)
 
         # test if the repo is still in the database
         new_repo = RepoModel().get_by_repo_name(repo_name)
         assert new_repo.repo_name == repo_name
 
         # check if repo is not in the filesystem
         assert not repo_on_filesystem(repo_name)
 
         # flush the session
         self.app.get(
             route_path('repo_summary', repo_name=safe_str(repo_name)),
             status=302)
 
         response = self.app.get(
             route_path('repo_creating_check', repo_name=safe_str(repo_name)),
             status=200)
         msg = 'The repository `%s` cannot be loaded in filesystem. ' \
               'Please check if it exist, or is not damaged.' % repo_name
         assert_session_flash(response, msg )
 
 
 @pytest.fixture()
 def summary_view(context_stub, request_stub, user_util):
     """
     Bootstrap view to test the view functions
     """
     request_stub.matched_route = AttributeDict(name='test_view')
 
     request_stub.user = user_util.create_user().AuthUser()
     request_stub.db_repo = user_util.create_repo()
 
     view = RepoSummaryView(context=context_stub, request=request_stub)
     return view
 
 
 @pytest.mark.usefixtures('app')
 class TestCreateReferenceData(object):
 
-    @pytest.fixture
+    @pytest.fixture()
     def example_refs(self):
         section_1_refs = OrderedDict((('a', 'a_id'), ('b', 'b_id')))
         example_refs = [
             ('section_1', section_1_refs, 't1'),
             ('section_2', {'c': 'c_id'}, 't2'),
         ]
         return example_refs
 
     def test_generates_refs_based_on_commit_ids(self, example_refs, summary_view):
         repo = mock.Mock()
         repo.name = 'test-repo'
         repo.alias = 'git'
         full_repo_name = 'pytest-repo-group/' + repo.name
 
         result = summary_view._create_reference_data(
             repo, full_repo_name, example_refs)
 
         expected_files_url = '/{}/files/'.format(full_repo_name)
         expected_result = [
             {
                 'children': [
                     {
                         'id': 'a', 'idx': 0, 'raw_id': 'a_id', 'text': 'a', 'type': 't1',
                         'files_url': expected_files_url + 'a/?at=a',
                     },
                     {
                         'id': 'b', 'idx': 0, 'raw_id': 'b_id', 'text': 'b', 'type': 't1',
                         'files_url': expected_files_url + 'b/?at=b',
                     }
                 ],
                 'text': 'section_1'
             },
             {
                 'children': [
                     {
                         'id': 'c', 'idx': 0, 'raw_id': 'c_id', 'text': 'c', 'type': 't2',
                         'files_url': expected_files_url + 'c/?at=c',
                     }
                 ],
                 'text': 'section_2'
             }]
         assert result == expected_result
 
     def test_generates_refs_with_path_for_svn(self, example_refs, summary_view):
         repo = mock.Mock()
         repo.name = 'test-repo'
         repo.alias = 'svn'
         full_repo_name = 'pytest-repo-group/' + repo.name
 
         result = summary_view._create_reference_data(
             repo, full_repo_name, example_refs)
 
         expected_files_url = '/{}/files/'.format(full_repo_name)
         expected_result = [
             {
                 'children': [
                     {
                         'id': 'a@a_id', 'idx': 0, 'raw_id': 'a_id',
                         'text': 'a', 'type': 't1',
                         'files_url': expected_files_url + 'a_id/a?at=a',
                     },
                     {
                         'id': 'b@b_id', 'idx': 0, 'raw_id': 'b_id',
                         'text': 'b', 'type': 't1',
                         'files_url': expected_files_url + 'b_id/b?at=b',
                     }
                 ],
                 'text': 'section_1'
             },
             {
                 'children': [
                     {
                         'id': 'c@c_id', 'idx': 0, 'raw_id': 'c_id',
                         'text': 'c', 'type': 't2',
                         'files_url': expected_files_url + 'c_id/c?at=c',
                     }
                 ],
                 'text': 'section_2'
             }
         ]
         assert result == expected_result
 
 
 class TestCreateFilesUrl(object):
 
     def test_creates_non_svn_url(self, app, summary_view):
         repo = mock.Mock()
         repo.name = 'abcde'
         full_repo_name = 'test-repo-group/' + repo.name
         ref_name = 'branch1'
         raw_id = 'deadbeef0123456789'
         is_svn = False
 
         with mock.patch('rhodecode.lib.helpers.route_path') as url_mock:
             result = summary_view._create_files_url(
                 repo, full_repo_name, ref_name, raw_id, is_svn)
         url_mock.assert_called_once_with(
             'repo_files', repo_name=full_repo_name, commit_id=ref_name,
             f_path='', _query=dict(at=ref_name))
         assert result == url_mock.return_value
 
     def test_creates_svn_url(self, app, summary_view):
         repo = mock.Mock()
         repo.name = 'abcde'
         full_repo_name = 'test-repo-group/' + repo.name
         ref_name = 'branch1'
         raw_id = 'deadbeef0123456789'
         is_svn = True
 
         with mock.patch('rhodecode.lib.helpers.route_path') as url_mock:
             result = summary_view._create_files_url(
                 repo, full_repo_name, ref_name, raw_id, is_svn)
         url_mock.assert_called_once_with(
             'repo_files', repo_name=full_repo_name, f_path=ref_name,
             commit_id=raw_id, _query=dict(at=ref_name))
         assert result == url_mock.return_value
 
     def test_name_has_slashes(self, app, summary_view):
         repo = mock.Mock()
         repo.name = 'abcde'
         full_repo_name = 'test-repo-group/' + repo.name
         ref_name = 'branch1/branch2'
         raw_id = 'deadbeef0123456789'
         is_svn = False
 
         with mock.patch('rhodecode.lib.helpers.route_path') as url_mock:
             result = summary_view._create_files_url(
                 repo, full_repo_name, ref_name, raw_id, is_svn)
         url_mock.assert_called_once_with(
             'repo_files', repo_name=full_repo_name, commit_id=raw_id,
             f_path='', _query=dict(at=ref_name))
         assert result == url_mock.return_value
 
 
 class TestReferenceItems(object):
     repo = mock.Mock()
     repo.name = 'pytest-repo'
     repo_full_name = 'pytest-repo-group/' + repo.name
     ref_type = 'branch'
     fake_url = '/abcde/'
 
     @staticmethod
     def _format_function(name, id_):
         return 'format_function_{}_{}'.format(name, id_)
 
     def test_creates_required_amount_of_items(self, summary_view):
         amount = 100
         refs = {
             'ref{}'.format(i): '{0:040d}'.format(i)
             for i in range(amount)
         }
 
         url_patcher = mock.patch.object(summary_view, '_create_files_url')
         svn_patcher = mock.patch('rhodecode.lib.helpers.is_svn',
                                  return_value=False)
 
         with url_patcher as url_mock, svn_patcher:
             result = summary_view._create_reference_items(
                 self.repo, self.repo_full_name, refs, self.ref_type,
                 self._format_function)
         assert len(result) == amount
         assert url_mock.call_count == amount
 
     def test_single_item_details(self, summary_view):
         ref_name = 'ref1'
         ref_id = 'deadbeef'
         refs = {
             ref_name: ref_id
         }
 
         svn_patcher = mock.patch('rhodecode.lib.helpers.is_svn',
                                  return_value=False)
 
         url_patcher = mock.patch.object(
             summary_view, '_create_files_url', return_value=self.fake_url)
 
         with url_patcher as url_mock, svn_patcher:
             result = summary_view._create_reference_items(
                 self.repo, self.repo_full_name, refs, self.ref_type,
                 self._format_function)
 
         url_mock.assert_called_once_with(
             self.repo, self.repo_full_name, ref_name, ref_id, False)
         expected_result = [
             {
                 'text': ref_name,
                 'id': self._format_function(ref_name, ref_id),
                 'raw_id': ref_id,
                 'idx': 0,
                 'type': self.ref_type,
                 'files_url': self.fake_url
             }
         ]
         assert result == expected_result

rhodecode/apps/ssh_support/tests/conftest.py

@@ -1,70 +1,70 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 import pytest
 from pyramid.compat import configparser
 
 from rhodecode.apps.ssh_support.lib.ssh_wrapper import SshWrapper
 from rhodecode.lib.utils2 import AttributeDict
 
 
[e-mail]
[e-mail]()
 def dummy_conf_file(tmpdir):
     conf = configparser.ConfigParser()
     conf.add_section('app:main')
     conf.set('app:main', 'ssh.executable.hg', '/usr/bin/hg')
     conf.set('app:main', 'ssh.executable.git', '/usr/bin/git')
     conf.set('app:main', 'ssh.executable.svn', '/usr/bin/svnserve')
 
     f_path = os.path.join(str(tmpdir), 'ssh_wrapper_test.ini')
     with open(f_path, 'wb') as f:
         conf.write(f)
 
     return os.path.join(f_path)
 
 
 def plain_dummy_env():
     return {
         'request':
             AttributeDict(host_url='http://localhost', script_name='/')
     }
 
 
[e-mail]
[e-mail]()
 def dummy_env():
     return plain_dummy_env()
 
 
 def plain_dummy_user():
     return AttributeDict(username='test_user')
 
 
[e-mail]
[e-mail]()
 def dummy_user():
     return plain_dummy_user()
 
 
[e-mail]
[e-mail]()
 def ssh_wrapper(app, dummy_conf_file, dummy_env):
     conn_info = '127.0.0.1 22 10.0.0.1 443'
     return SshWrapper(
         'random command', conn_info, 'auto', 'admin', '1', key_id='1',
         shell=False, ini_path=dummy_conf_file, env=dummy_env)

rhodecode/apps/ssh_support/tests/test_server_git.py

@@ -1,152 +1,152 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import json
 import mock
 import pytest
 
 from rhodecode.apps.ssh_support.lib.backends.git import GitServer
 from rhodecode.apps.ssh_support.tests.conftest import plain_dummy_env, plain_dummy_user
 
 
 class GitServerCreator(object):
     root = '/tmp/repo/path/'
     git_path = '/usr/local/bin/git'
     config_data = {
         'app:main': {
             'ssh.executable.git': git_path,
             'vcs.hooks.protocol': 'http',
         }
     }
     repo_name = 'test_git'
     repo_mode = 'receive-pack'
     user = plain_dummy_user()
 
     def __init__(self):
         def config_get(part, key):
             return self.config_data.get(part, {}).get(key)
         self.config_mock = mock.Mock()
         self.config_mock.get = mock.Mock(side_effect=config_get)
 
     def create(self, **kwargs):
         parameters = {
             'store': self.root,
             'ini_path': '',
             'user': self.user,
             'repo_name': self.repo_name,
             'repo_mode': self.repo_mode,
             'user_permissions': {
                 self.repo_name: 'repository.admin'
             },
             'config': self.config_mock,
             'env': plain_dummy_env()
         }
         parameters.update(kwargs)
         server = GitServer(**parameters)
         return server
 
 
[e-mail]
[e-mail]()
 def git_server(app):
     return GitServerCreator()
 
 
 class TestGitServer(object):
 
     def test_command(self, git_server):
         server = git_server.create()
         expected_command = (
             'cd {root}; {git_path} {repo_mode} \'{root}{repo_name}\''.format(
                 root=git_server.root, git_path=git_server.git_path,
                 repo_mode=git_server.repo_mode, repo_name=git_server.repo_name)
         )
         assert expected_command == server.tunnel.command()
 
     @pytest.mark.parametrize('permissions, action, code', [
         ({}, 'pull', -2),
         ({'test_git': 'repository.read'}, 'pull', 0),
         ({'test_git': 'repository.read'}, 'push', -2),
         ({'test_git': 'repository.write'}, 'push', 0),
         ({'test_git': 'repository.admin'}, 'push', 0),
 
     ])
     def test_permission_checks(self, git_server, permissions, action, code):
         server = git_server.create(user_permissions=permissions)
         result = server._check_permissions(action)
         assert result is code
 
     @pytest.mark.parametrize('permissions, value', [
         ({}, False),
         ({'test_git': 'repository.read'}, False),
         ({'test_git': 'repository.write'}, True),
         ({'test_git': 'repository.admin'}, True),
 
     ])
     def test_has_write_permissions(self, git_server, permissions, value):
         server = git_server.create(user_permissions=permissions)
         result = server.has_write_perm()
         assert result is value
 
     def test_run_returns_executes_command(self, git_server):
         server = git_server.create()
         from rhodecode.apps.ssh_support.lib.backends.git import GitTunnelWrapper
         with mock.patch.object(GitTunnelWrapper, 'create_hooks_env') as _patch:
             _patch.return_value = 0
             with mock.patch.object(GitTunnelWrapper, 'command', return_value='date'):
                 exit_code = server.run()
 
         assert exit_code == (0, False)
 
     @pytest.mark.parametrize(
         'repo_mode, action', [
             ['receive-pack', 'push'],
             ['upload-pack', 'pull']
         ])
     def test_update_environment(self, git_server, repo_mode, action):
         server = git_server.create(repo_mode=repo_mode)
         store = server.store
 
         with mock.patch('os.environ', {'SSH_CLIENT': '10.10.10.10 b'}):
             with mock.patch('os.putenv') as putenv_mock:
                 server.update_environment(action)
 
         expected_data = {
             'username': git_server.user.username,
             'user_id': git_server.user.user_id,
             'scm': 'git',
             'repository': git_server.repo_name,
             'make_lock': None,
             'action': action,
             'ip': '10.10.10.10',
             'locked_by': [None, None],
             'config': '',
             'repo_store': store,
             'server_url': None,
             'hooks': ['push', 'pull'],
             'is_shadow_repo': False,
             'hooks_module': 'rhodecode.lib.hooks_daemon',
             'check_branch_perms': False,
             'detect_force_push': False,
             'user_agent': u'ssh-user-agent',
             'SSH': True,
             'SSH_PERMISSIONS': 'repository.admin',
         }
         args, kwargs = putenv_mock.call_args
         assert json.loads(args[1]) == expected_data

rhodecode/apps/ssh_support/tests/test_server_hg.py

@@ -1,119 +1,119 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 import mock
 import pytest
 
 from rhodecode.apps.ssh_support.lib.backends.hg import MercurialServer
 from rhodecode.apps.ssh_support.tests.conftest import plain_dummy_env, plain_dummy_user
 
 
 class MercurialServerCreator(object):
     root = '/tmp/repo/path/'
     hg_path = '/usr/local/bin/hg'
 
     config_data = {
         'app:main': {
             'ssh.executable.hg': hg_path,
             'vcs.hooks.protocol': 'http',
         }
     }
     repo_name = 'test_hg'
     user = plain_dummy_user()
 
     def __init__(self):
         def config_get(part, key):
             return self.config_data.get(part, {}).get(key)
         self.config_mock = mock.Mock()
         self.config_mock.get = mock.Mock(side_effect=config_get)
 
     def create(self, **kwargs):
         parameters = {
             'store': self.root,
             'ini_path': '',
             'user': self.user,
             'repo_name': self.repo_name,
             'user_permissions': {
                 'test_hg': 'repository.admin'
             },
             'config': self.config_mock,
             'env': plain_dummy_env()
         }
         parameters.update(kwargs)
         server = MercurialServer(**parameters)
         return server
 
 
[e-mail]
[e-mail]()
 def hg_server(app):
     return MercurialServerCreator()
 
 
 class TestMercurialServer(object):
 
     def test_command(self, hg_server, tmpdir):
         server = hg_server.create()
         custom_hgrc = os.path.join(str(tmpdir), 'hgrc')
         expected_command = (
             'cd {root}; HGRCPATH={custom_hgrc} {hg_path} -R {root}{repo_name} serve --stdio'.format(
                 root=hg_server.root, custom_hgrc=custom_hgrc, hg_path=hg_server.hg_path,
                 repo_name=hg_server.repo_name)
         )
         server_command = server.tunnel.command(custom_hgrc)
         assert expected_command == server_command
 
     @pytest.mark.parametrize('permissions, action, code', [
         ({}, 'pull', -2),
         ({'test_hg': 'repository.read'}, 'pull', 0),
         ({'test_hg': 'repository.read'}, 'push', -2),
         ({'test_hg': 'repository.write'}, 'push', 0),
         ({'test_hg': 'repository.admin'}, 'push', 0),
 
     ])
     def test_permission_checks(self, hg_server, permissions, action, code):
         server = hg_server.create(user_permissions=permissions)
         result = server._check_permissions(action)
         assert result is code
 
     @pytest.mark.parametrize('permissions, value', [
         ({}, False),
         ({'test_hg': 'repository.read'}, False),
         ({'test_hg': 'repository.write'}, True),
         ({'test_hg': 'repository.admin'}, True),
 
     ])
     def test_has_write_permissions(self, hg_server, permissions, value):
         server = hg_server.create(user_permissions=permissions)
         result = server.has_write_perm()
         assert result is value
 
     def test_run_returns_executes_command(self, hg_server):
         server = hg_server.create()
         from rhodecode.apps.ssh_support.lib.backends.hg import MercurialTunnelWrapper
         with mock.patch.object(MercurialTunnelWrapper, 'create_hooks_env') as _patch:
             _patch.return_value = 0
             with mock.patch.object(MercurialTunnelWrapper, 'command', return_value='date'):
                 exit_code = server.run()
 
         assert exit_code == (0, False)
 
 
 

rhodecode/apps/ssh_support/tests/test_server_svn.py

@@ -1,124 +1,124 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 from rhodecode.apps.ssh_support.lib.backends.svn import SubversionServer
 from rhodecode.apps.ssh_support.tests.conftest import plain_dummy_env, plain_dummy_user
 
 
 class SubversionServerCreator(object):
     root = '/tmp/repo/path/'
     svn_path = '/usr/local/bin/svnserve'
     config_data = {
         'app:main': {
             'ssh.executable.svn': svn_path,
             'vcs.hooks.protocol': 'http',
         }
     }
     repo_name = 'test-svn'
     user = plain_dummy_user()
 
     def __init__(self):
         def config_get(part, key):
             return self.config_data.get(part, {}).get(key)
         self.config_mock = mock.Mock()
         self.config_mock.get = mock.Mock(side_effect=config_get)
 
     def create(self, **kwargs):
         parameters = {
             'store': self.root,
             'repo_name': self.repo_name,
             'ini_path': '',
             'user': self.user,
             'user_permissions': {
                 self.repo_name: 'repository.admin'
             },
             'config': self.config_mock,
             'env': plain_dummy_env()
         }
 
         parameters.update(kwargs)
         server = SubversionServer(**parameters)
         return server
 
 
[e-mail]
[e-mail]()
 def svn_server(app):
     return SubversionServerCreator()
 
 
 class TestSubversionServer(object):
     def test_command(self, svn_server):
         server = svn_server.create()
         expected_command = [
             svn_server.svn_path, '-t', '--config-file',
             server.tunnel.svn_conf_path, '-r', svn_server.root
         ]
 
         assert expected_command == server.tunnel.command()
 
     @pytest.mark.parametrize('permissions, action, code', [
         ({}, 'pull', -2),
         ({'test-svn': 'repository.read'}, 'pull', 0),
         ({'test-svn': 'repository.read'}, 'push', -2),
         ({'test-svn': 'repository.write'}, 'push', 0),
         ({'test-svn': 'repository.admin'}, 'push', 0),
 
     ])
     def test_permission_checks(self, svn_server, permissions, action, code):
         server = svn_server.create(user_permissions=permissions)
         result = server._check_permissions(action)
         assert result is code
 
     def test_run_returns_executes_command(self, svn_server):
         server = svn_server.create()
         from rhodecode.apps.ssh_support.lib.backends.svn import SubversionTunnelWrapper
         with mock.patch.object(
                 SubversionTunnelWrapper, 'get_first_client_response',
                 return_value={'url': 'http://server/test-svn'}):
             with mock.patch.object(
                     SubversionTunnelWrapper, 'patch_first_client_response',
                     return_value=0):
                 with mock.patch.object(
                         SubversionTunnelWrapper, 'sync',
                         return_value=0):
                     with mock.patch.object(
                             SubversionTunnelWrapper, 'command',
                             return_value=['date']):
 
                         exit_code = server.run()
         # SVN has this differently configured, and we get in our mock env
         # None as return code
         assert exit_code == (None, False)
 
     def test_run_returns_executes_command_that_cannot_extract_repo_name(self, svn_server):
         server = svn_server.create()
         from rhodecode.apps.ssh_support.lib.backends.svn import SubversionTunnelWrapper
         with mock.patch.object(
                 SubversionTunnelWrapper, 'command',
                 return_value=['date']):
             with mock.patch.object(
                     SubversionTunnelWrapper, 'get_first_client_response',
                     return_value=None):
                     exit_code = server.run()
 
         assert exit_code == (1, False)

rhodecode/config/patches.py

@@ -1,98 +1,97 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Compatibility patches.
 
 Please keep the following principles in mind:
 
 * Keep imports local, so that importing this module does not cause too many
   side effects by itself.
 
 * Try to make patches idempotent, calling them multiple times should not do
   harm. If that is not possible, ensure that the second call explodes.
 
 """
 
 
-
 def inspect_getargspec():
     """
     Pyramid rely on inspect.getargspec to lookup the signature of
     view functions. This is not compatible with cython, therefore we replace
     getargspec with a custom version.
     Code is inspired by the inspect module from Python-3.4
     """
     import inspect
 
     def _isCython(func):
         """
         Private helper that checks if a function is a cython function.
         """
         return func.__class__.__name__ == 'cython_function_or_method'
 
     def unwrap(func):
         """
         Get the object wrapped by *func*.
 
         Follows the chain of :attr:`__wrapped__` attributes returning the last
         object in the chain.
 
         *stop* is an optional callback accepting an object in the wrapper chain
         as its sole argument that allows the unwrapping to be terminated early
         if the callback returns a true value. If the callback never returns a
         true value, the last object in the chain is returned as usual. For
         example, :func:`signature` uses this to stop unwrapping if any object
         in the chain has a ``__signature__`` attribute defined.
 
         :exc:`ValueError` is raised if a cycle is encountered.
         """
         f = func  # remember the original func for error reporting
         memo = {id(f)}  # Memoise by id to tolerate non-hashable objects
         while hasattr(func, '__wrapped__'):
             func = func.__wrapped__
             id_func = id(func)
             if id_func in memo:
                 raise ValueError('wrapper loop when unwrapping {!r}'.format(f))
             memo.add(id_func)
         return func
 
     def custom_getargspec(func):
         """
         Get the names and default values of a function's arguments.
 
         A tuple of four things is returned: (args, varargs, varkw, defaults).
         'args' is a list of the argument names (it may contain nested lists).
         'varargs' and 'varkw' are the names of the * and ** arguments or None.
         'defaults' is an n-tuple of the default values of the last n arguments.
         """
 
         func = unwrap(func)
 
         if inspect.ismethod(func):
             func = func.im_func
         if not inspect.isfunction(func):
             if not _isCython(func):
                 raise TypeError('{!r} is not a Python or Cython function'
                                 .format(func))
         args, varargs, varkw = inspect.getargs(func.func_code)
         return inspect.ArgSpec(args, varargs, varkw, func.func_defaults)
 
     inspect.getargspec = custom_getargspec

rhodecode/tests/config/test_environment.py

@@ -1,53 +1,53 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import mock
 import pytest
 
 from rhodecode.config import environment
 
 
[e-mail]
[e-mail]()
 def _external_calls_patcher(request):
     # TODO: mikhail: This is a temporary solution. Ideally load_environment
     # should be split into multiple small testable functions.
     utils_patcher = mock.patch.object(environment, 'utils')
 
     rhodecode_patcher = mock.patch.object(environment, 'rhodecode')
 
     db_config = mock.Mock()
     db_config.items.return_value = {
         'paths': [['/tmp/abc', '/tmp/def']]
     }
     db_config_patcher = mock.patch.object(
         environment, 'make_db_config', return_value=db_config)
 
     set_config_patcher = mock.patch.object(environment, 'set_rhodecode_config')
 
     utils_patcher.start()
     rhodecode_patcher.start()
     db_config_patcher.start()
     set_config_patcher.start()
 
     request.addfinalizer(utils_patcher.stop)
     request.addfinalizer(rhodecode_patcher.stop)
     request.addfinalizer(db_config_patcher.stop)
     request.addfinalizer(set_config_patcher.stop)

rhodecode/tests/database/conftest.py

@@ -1,292 +1,292 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 from subprocess32 import Popen, PIPE
 import os
 import shutil
 import sys
 import tempfile
 
 import pytest
 from sqlalchemy.engine import url
 
 from rhodecode.tests.fixture import TestINI
 
 
 def _get_dbs_from_metafunc(metafunc):
     if hasattr(metafunc.function, 'dbs'):
         # Supported backends by this test function, created from
         # pytest.mark.dbs
         backends = metafunc.definition.get_closest_marker('dbs').args
     else:
         backends = metafunc.config.getoption('--dbs')
     return backends
 
 
 def pytest_generate_tests(metafunc):
     # Support test generation based on --dbs parameter
     if 'db_backend' in metafunc.fixturenames:
         requested_backends = set(metafunc.config.getoption('--dbs'))
         backends = _get_dbs_from_metafunc(metafunc)
         backends = requested_backends.intersection(backends)
         # TODO: johbo: Disabling a backend did not work out with
         # parametrization, find better way to achieve this.
         if not backends:
             metafunc.function._skip = True
         metafunc.parametrize('db_backend_name', backends)
 
 
 def pytest_collection_modifyitems(session, config, items):
     remaining = [
         i for i in items if not getattr(i.obj, '_skip', False)]
     items[:] = remaining
 
 
[e-mail]
[e-mail]()
 def db_backend(
         request, db_backend_name, ini_config, tmpdir_factory):
     basetemp = tmpdir_factory.getbasetemp().strpath
     klass = _get_backend(db_backend_name)
 
     option_name = '--{}-connection-string'.format(db_backend_name)
     connection_string = request.config.getoption(option_name) or None
 
     return klass(
         config_file=ini_config, basetemp=basetemp,
         connection_string=connection_string)
 
 
 def _get_backend(backend_type):
     return {
         'sqlite': SQLiteDBBackend,
         'postgres': PostgresDBBackend,
         'mysql': MySQLDBBackend,
         '': EmptyDBBackend
     }[backend_type]
 
 
 class DBBackend(object):
     _store = os.path.dirname(os.path.abspath(__file__))
     _type = None
     _base_ini_config = [{'app:main': {'vcs.start_server': 'false',
                                       'startup.import_repos': 'false',
                                       'is_test': 'False'}}]
     _db_url = [{'app:main': {'sqlalchemy.db1.url': ''}}]
     _base_db_name = 'rhodecode_test_db_backend'
 
     def __init__(
             self, config_file, db_name=None, basetemp=None,
             connection_string=None):
 
         from rhodecode.lib.vcs.backends.hg import largefiles_store
         from rhodecode.lib.vcs.backends.git import lfs_store
 
         self.fixture_store = os.path.join(self._store, self._type)
         self.db_name = db_name or self._base_db_name
         self._base_ini_file = config_file
         self.stderr = ''
         self.stdout = ''
         self._basetemp = basetemp or tempfile.gettempdir()
         self._repos_location = os.path.join(self._basetemp, 'rc_test_repos')
         self._repos_hg_largefiles_store = largefiles_store(self._basetemp)
         self._repos_git_lfs_store = lfs_store(self._basetemp)
         self.connection_string = connection_string
 
     @property
     def connection_string(self):
         return self._connection_string
 
     @connection_string.setter
     def connection_string(self, new_connection_string):
         if not new_connection_string:
             new_connection_string = self.get_default_connection_string()
         else:
             new_connection_string = new_connection_string.format(
                 db_name=self.db_name)
         url_parts = url.make_url(new_connection_string)
         self._connection_string = new_connection_string
         self.user = url_parts.username
         self.password = url_parts.password
         self.host = url_parts.host
 
     def get_default_connection_string(self):
         raise NotImplementedError('default connection_string is required.')
 
     def execute(self, cmd, env=None, *args):
         """
         Runs command on the system with given ``args``.
         """
 
         command = cmd + ' ' + ' '.join(args)
         sys.stdout.write(command)
 
         # Tell Python to use UTF-8 encoding out stdout
         _env = os.environ.copy()
         _env['PYTHONIOENCODING'] = 'UTF-8'
         if env:
             _env.update(env)
         self.p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, env=_env)
         self.stdout, self.stderr = self.p.communicate()
         sys.stdout.write('COMMAND:'+command+'\n')
         sys.stdout.write(self.stdout)
         return self.stdout, self.stderr
 
     def assert_returncode_success(self):
         if not self.p.returncode == 0:
             print(self.stderr)
             raise AssertionError('non 0 retcode:{}'.format(self.p.returncode))
 
     def assert_correct_output(self, stdout, version):
         assert 'UPGRADE FOR STEP {} COMPLETED'.format(version) in stdout
 
     def setup_rhodecode_db(self, ini_params=None, env=None):
         if not ini_params:
             ini_params = self._base_ini_config
 
         ini_params.extend(self._db_url)
         with TestINI(self._base_ini_file, ini_params,
                      self._type, destroy=True) as _ini_file:
 
             if not os.path.isdir(self._repos_location):
                 os.makedirs(self._repos_location)
             if not os.path.isdir(self._repos_hg_largefiles_store):
                 os.makedirs(self._repos_hg_largefiles_store)
             if not os.path.isdir(self._repos_git_lfs_store):
                 os.makedirs(self._repos_git_lfs_store)
 
             return self.execute(
                 "rc-setup-app {0} --user=marcink "
                 "--email=[e-mail] --password={1} "
                 "--repos={2} --force-yes".format(
                     _ini_file, 'qweqwe', self._repos_location), env=env)
 
     def upgrade_database(self, ini_params=None):
         if not ini_params:
             ini_params = self._base_ini_config
         ini_params.extend(self._db_url)
 
         test_ini = TestINI(
             self._base_ini_file, ini_params, self._type, destroy=True)
         with test_ini as ini_file:
             if not os.path.isdir(self._repos_location):
                 os.makedirs(self._repos_location)
 
             return self.execute(
                 "rc-upgrade-db {0} --force-yes".format(ini_file))
 
     def setup_db(self):
         raise NotImplementedError
 
     def teardown_db(self):
         raise NotImplementedError
 
     def import_dump(self, dumpname):
         raise NotImplementedError
 
 
 class EmptyDBBackend(DBBackend):
     _type = ''
 
     def setup_db(self):
         pass
 
     def teardown_db(self):
         pass
 
     def import_dump(self, dumpname):
         pass
 
     def assert_returncode_success(self):
         assert True
 
 
 class SQLiteDBBackend(DBBackend):
     _type = 'sqlite'
 
     def get_default_connection_string(self):
         return 'sqlite:///{}/{}.sqlite'.format(self._basetemp, self.db_name)
 
     def setup_db(self):
         # dump schema for tests
         # cp -v $TEST_DB_NAME
         self._db_url = [{'app:main': {
             'sqlalchemy.db1.url': self.connection_string}}]
 
     def import_dump(self, dumpname):
         dump = os.path.join(self.fixture_store, dumpname)
         target = os.path.join(self._basetemp, '{0.db_name}.sqlite'.format(self))
         return self.execute('cp -v {} {}'.format(dump, target))
 
     def teardown_db(self):
         return self.execute("rm -rf {}.sqlite".format(
             os.path.join(self._basetemp, self.db_name)))
 
 
 class MySQLDBBackend(DBBackend):
     _type = 'mysql'
 
     def get_default_connection_string(self):
         return 'mysql://root:qweqwe@127.0.0.1/{}'.format(self.db_name)
 
     def setup_db(self):
         # dump schema for tests
         # mysqldump -uroot -pqweqwe $TEST_DB_NAME
         self._db_url = [{'app:main': {
             'sqlalchemy.db1.url': self.connection_string}}]
         return self.execute("mysql -v -u{} -p{} -e 'create database '{}';'".format(
             self.user, self.password, self.db_name))
 
     def import_dump(self, dumpname):
         dump = os.path.join(self.fixture_store, dumpname)
         return self.execute("mysql -u{} -p{} {} < {}".format(
             self.user, self.password, self.db_name, dump))
 
     def teardown_db(self):
         return self.execute("mysql -v -u{} -p{} -e 'drop database '{}';'".format(
             self.user, self.password, self.db_name))
 
 
 class PostgresDBBackend(DBBackend):
     _type = 'postgres'
 
     def get_default_connection_string(self):
         return 'postgresql://postgres:qweqwe@localhost/{}'.format(self.db_name)
 
     def setup_db(self):
         # dump schema for tests
         # pg_dump -U postgres -h localhost $TEST_DB_NAME
         self._db_url = [{'app:main': {
             'sqlalchemy.db1.url':
                 self.connection_string}}]
         return self.execute("PGPASSWORD={} psql -U {} -h localhost "
                      "-c 'create database '{}';'".format(
                          self.password, self.user, self.db_name))
 
     def teardown_db(self):
         return self.execute("PGPASSWORD={} psql -U {} -h localhost "
                      "-c 'drop database if exists '{}';'".format(
                          self.password, self.user, self.db_name))
 
     def import_dump(self, dumpname):
         dump = os.path.join(self.fixture_store, dumpname)
         return self.execute(
             "PGPASSWORD={} psql -U {} -h localhost -d {} -1 "
             "-f {}".format(
                 self.password, self.user, self.db_name, dump))

rhodecode/tests/events/test_repo.py

@@ -1,123 +1,123 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
 
 from rhodecode.tests.events.conftest import EventCatcher
 
 from rhodecode.lib import hooks_base, utils2
 from rhodecode.model.repo import RepoModel
 from rhodecode.events.repo import (
     RepoPrePullEvent, RepoPullEvent,
     RepoPrePushEvent, RepoPushEvent,
     RepoPreCreateEvent, RepoCreateEvent,
     RepoPreDeleteEvent, RepoDeleteEvent,
 )
 
 
[e-mail]
[e-mail]()
 def scm_extras(user_regular, repo_stub):
     extras = utils2.AttributeDict({
         'ip': '127.0.0.1',
         'username': user_regular.username,
         'user_id': user_regular.user_id,
         'action': '',
         'repository': repo_stub.repo_name,
         'scm': repo_stub.scm_instance().alias,
         'config': '',
         'repo_store': '',
         'server_url': 'http://example.com',
         'make_lock': None,
         'user_agent': 'some-client',
         'locked_by': [None],
         'commit_ids': ['a' * 40] * 3,
         'hook_type': 'scm_extras_test',
         'is_shadow_repo': False,
     })
     return extras
 
 
 # TODO: dan: make the serialization tests complete json comparisons
 @pytest.mark.parametrize('EventClass', [
     RepoPreCreateEvent, RepoCreateEvent,
     RepoPreDeleteEvent, RepoDeleteEvent,
 ])
 def test_repo_events_serialized(config_stub, repo_stub, EventClass):
     event = EventClass(repo_stub)
     data = event.as_dict()
     assert data['name'] == EventClass.name
     assert data['repo']['repo_name'] == repo_stub.repo_name
     assert data['repo']['url']
     assert data['repo']['permalink_url']
 
 
 @pytest.mark.parametrize('EventClass', [
     RepoPrePullEvent, RepoPullEvent, RepoPrePushEvent
 ])
 def test_vcs_repo_events_serialize(config_stub, repo_stub, scm_extras, EventClass):
     event = EventClass(repo_name=repo_stub.repo_name, extras=scm_extras)
     data = event.as_dict()
     assert data['name'] == EventClass.name
     assert data['repo']['repo_name'] == repo_stub.repo_name
     assert data['repo']['url']
     assert data['repo']['permalink_url']
 
 
 @pytest.mark.parametrize('EventClass', [RepoPushEvent])
 def test_vcs_repo_push_event_serialize(config_stub, repo_stub, scm_extras, EventClass):
     event = EventClass(repo_name=repo_stub.repo_name,
                        pushed_commit_ids=scm_extras['commit_ids'],
                        extras=scm_extras)
     data = event.as_dict()
     assert data['name'] == EventClass.name
     assert data['repo']['repo_name'] == repo_stub.repo_name
     assert data['repo']['url']
     assert data['repo']['permalink_url']
 
 
 def test_create_delete_repo_fires_events(backend):
     with EventCatcher() as event_catcher:
         repo = backend.create_repo()
     assert event_catcher.events_types == [RepoPreCreateEvent, RepoCreateEvent]
 
     with EventCatcher() as event_catcher:
         RepoModel().delete(repo)
     assert event_catcher.events_types == [RepoPreDeleteEvent, RepoDeleteEvent]
 
 
 def test_pull_fires_events(scm_extras):
     with EventCatcher() as event_catcher:
         hooks_base.pre_push(scm_extras)
     assert event_catcher.events_types == [RepoPrePushEvent]
 
     with EventCatcher() as event_catcher:
         hooks_base.post_push(scm_extras)
     assert event_catcher.events_types == [RepoPushEvent]
 
 
 def test_push_fires_events(scm_extras):
     with EventCatcher() as event_catcher:
         hooks_base.pre_pull(scm_extras)
     assert event_catcher.events_types == [RepoPrePullEvent]
 
     with EventCatcher() as event_catcher:
         hooks_base.post_pull(scm_extras)
     assert event_catcher.events_types == [RepoPullEvent]
 

rhodecode/tests/integrations/conftest.py

@@ -1,55 +1,55 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import pytest
 from rhodecode import events
 from rhodecode.lib.utils2 import AttributeDict
 
 
[e-mail]
[e-mail]()
 def repo_push_event(backend, user_regular):
     commits = [
         {'message': 'ancestor commit fixes #15'},
         {'message': 'quick fixes'},
         {'message': 'change that fixes #41, #2'},
         {'message': 'this is because 5b23c3532 broke stuff'},
         {'message': 'last commit'},
     ]
     commit_ids = backend.create_master_repo(commits).values()
     repo = backend.create_repo()
     scm_extras = AttributeDict({
         'ip': '127.0.0.1',
         'username': user_regular.username,
         'user_id': user_regular.user_id,
         'action': '',
         'repository': repo.repo_name,
         'scm': repo.scm_instance().alias,
         'config': '',
         'repo_store': '',
         'server_url': 'http://example.com',
         'make_lock': None,
         'locked_by': [None],
         'commit_ids': commit_ids,
     })
 
     return events.RepoPushEvent(repo_name=repo.repo_name,
                                 pushed_commit_ids=commit_ids,
                                 extras=scm_extras)

rhodecode/tests/integrations/test_integration.py

@@ -1,216 +1,216 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import time
 import pytest
 
 from rhodecode import events
 from rhodecode.tests.fixture import Fixture
 from rhodecode.model.db import Session, Integration
 from rhodecode.model.integration import IntegrationModel
 
 
 class TestDeleteScopesDeletesIntegrations(object):
     def test_delete_repo_with_integration_deletes_integration(
             self, repo_integration_stub):
 
         Session().delete(repo_integration_stub.repo)
         Session().commit()
         Session().expire_all()
         integration = Integration.get(repo_integration_stub.integration_id)
         assert integration is None
 
     def test_delete_repo_group_with_integration_deletes_integration(
             self, repogroup_integration_stub):
 
         Session().delete(repogroup_integration_stub.repo_group)
         Session().commit()
         Session().expire_all()
         integration = Integration.get(repogroup_integration_stub.integration_id)
         assert integration is None
 
 
[e-mail]
[e-mail]()
 def integration_repos(request, StubIntegrationType, stub_integration_settings):
     """
     Create repositories and integrations for testing, and destroy them after
 
     Structure:
         root_repo
         parent_group/
             parent_repo
             child_group/
                 child_repo
         other_group/
             other_repo
     """
     fixture = Fixture()
 
 
     parent_group_id = 'int_test_parent_group_%s' % time.time()
     parent_group = fixture.create_repo_group(parent_group_id)
 
     other_group_id = 'int_test_other_group_%s' % time.time()
     other_group = fixture.create_repo_group(other_group_id)
 
     child_group_id = (
         parent_group_id + '/' + 'int_test_child_group_%s' % time.time())
     child_group = fixture.create_repo_group(child_group_id)
 
     parent_repo_id = 'int_test_parent_repo_%s' % time.time()
     parent_repo = fixture.create_repo(parent_repo_id, repo_group=parent_group)
 
     child_repo_id = 'int_test_child_repo_%s' % time.time()
     child_repo = fixture.create_repo(child_repo_id, repo_group=child_group)
 
     other_repo_id = 'int_test_other_repo_%s' % time.time()
     other_repo = fixture.create_repo(other_repo_id, repo_group=other_group)
 
     root_repo_id = 'int_test_repo_root_%s' % time.time()
     root_repo = fixture.create_repo(root_repo_id)
 
     integrations = {}
     for name, repo, repo_group, child_repos_only in [
             ('global', None, None, None),
             ('root_repos', None, None, True),
             ('parent_repo', parent_repo, None, None),
             ('child_repo', child_repo, None, None),
             ('other_repo', other_repo, None, None),
             ('root_repo', root_repo, None, None),
             ('parent_group', None, parent_group, True),
             ('parent_group_recursive', None, parent_group, False),
             ('child_group', None, child_group, True),
             ('child_group_recursive', None, child_group, False),
             ('other_group', None, other_group, True),
             ('other_group_recursive', None, other_group, False),
         ]:
         integrations[name] = IntegrationModel().create(
             StubIntegrationType, settings=stub_integration_settings,
             enabled=True, name='test %s integration' % name,
             repo=repo, repo_group=repo_group, child_repos_only=child_repos_only)
 
     Session().commit()
 
     def _cleanup():
         for integration in integrations.values():
             Session.delete(integration)
 
         fixture.destroy_repo(root_repo)
         fixture.destroy_repo(child_repo)
         fixture.destroy_repo(parent_repo)
         fixture.destroy_repo(other_repo)
         fixture.destroy_repo_group(child_group)
         fixture.destroy_repo_group(parent_group)
         fixture.destroy_repo_group(other_group)
 
     request.addfinalizer(_cleanup)
 
     return {
         'integrations': integrations,
         'repos': {
             'root_repo': root_repo,
             'other_repo': other_repo,
             'parent_repo': parent_repo,
             'child_repo': child_repo,
         }
     }
 
 
 def test_enabled_integration_repo_scopes(integration_repos):
     integrations = integration_repos['integrations']
     repos = integration_repos['repos']
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['root_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['root_repos'],
         integrations['root_repo'],
     ]
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['other_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['other_group'],
         integrations['other_group_recursive'],
         integrations['other_repo'],
     ]
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['parent_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['parent_group'],
         integrations['parent_group_recursive'],
         integrations['parent_repo'],
     ]
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['child_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
         integrations['child_group'],
         integrations['parent_group_recursive'],
         integrations['child_group_recursive'],
         integrations['child_repo'],
     ]
 
 
 def test_disabled_integration_repo_scopes(integration_repos):
     integrations = integration_repos['integrations']
     repos = integration_repos['repos']
 
     for integration in integrations.values():
         integration.enabled = False
     Session().commit()
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['root_repo']))
 
     assert triggered_integrations == []
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['parent_repo']))
 
     assert triggered_integrations == []
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['child_repo']))
 
     assert triggered_integrations == []
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['other_repo']))
 
     assert triggered_integrations == []
 
 
 def test_enabled_non_repo_integrations(integration_repos):
     integrations = integration_repos['integrations']
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.UserPreCreate({}))
 
     assert triggered_integrations == [integrations['global']]

rhodecode/tests/integrations/test_slack.py

@@ -1,66 +1,66 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
 from mock import patch
 
 from rhodecode import events
 from rhodecode.model.db import Session, Integration
 from rhodecode.integrations.types.slack import SlackIntegrationType
 
 
[e-mail]
[e-mail]()
 def slack_settings():
     return {
         "service": "mock://slackintegration",
         "events": [
            "pullrequest-create",
            "repo-push",
         ],
         "channel": "#testing",
         "icon_emoji": ":recycle:",
         "username": "rhodecode-test"
     }
 
 
[e-mail]
[e-mail]()
 def slack_integration(request, app, slack_settings):
     integration = Integration()
     integration.name = 'test slack integration'
     integration.enabled = True
     integration.integration_type = SlackIntegrationType.key
     integration.settings = slack_settings
     Session().add(integration)
     Session().commit()
     request.addfinalizer(lambda: Session().delete(integration))
     return integration
 
 
 def test_slack_push(slack_integration, repo_push_event):
     with patch('rhodecode.integrations.types.slack.post_text_to_slack') as call:
         events.trigger(repo_push_event)
     assert 'pushed to' in call.call_args[0][1]
 
     slack_integration.settings['events'] = []
     Session().commit()
 
     with patch('rhodecode.integrations.types.slack.post_text_to_slack') as call:
         events.trigger(repo_push_event)
     assert not call.call_args

rhodecode/tests/integrations/test_webhook.py

@@ -1,135 +1,135 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
 
 from rhodecode import events
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.integrations.types.webhook import WebhookDataHandler
 
 
[e-mail]
[e-mail]()
 def base_data():
     return {
         'name': 'event',
         'repo': {
             'repo_name': 'foo',
             'repo_type': 'hg',
             'repo_id': '12',
             'url': 'http://repo.url/foo',
             'extra_fields': {},
         },
         'actor': {
             'username': 'actor_name',
             'user_id': 1
         }
     }
 
 
 def test_webhook_parse_url_invalid_event():
     template_url = 'http://server.com/${repo_name}/build'
     handler = WebhookDataHandler(
         template_url, {'exmaple-header': 'header-values'})
     event = events.RepoDeleteEvent('')
     with pytest.raises(ValueError) as err:
         handler(event, {})
 
     err = str(err.value)
     assert err.startswith(
         'event type `%s` not in supported list' % event.__class__)
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${repo_name}/build',
      ['http://server.com/foo/build']),
     ('http://server.com/${repo_name}/${repo_type}',
      ['http://server.com/foo/hg']),
     ('http://${server}.com/${repo_name}/${repo_id}',
      ['http://${server}.com/foo/12']),
     ('http://server.com/${branch}/build',
      ['http://server.com/${branch}/build']),
 ])
 def test_webook_parse_url_for_create_event(base_data, template, expected_urls):
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(events.RepoCreateEvent(''), base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${repo_name}/${pull_request_id}',
      ['http://server.com/foo/999']),
     ('http://server.com/${repo_name}/${pull_request_url}',
      ['http://server.com/foo/http%3A//pr-url.com']),
     ('http://server.com/${repo_name}/${pull_request_url}/?TITLE=${pull_request_title}',
      ['http://server.com/foo/http%3A//pr-url.com/?TITLE=example-pr-title%20Ticket%20%23123']),
     ('http://server.com/${repo_name}/?SHADOW_URL=${pull_request_shadow_url}',
      ['http://server.com/foo/?SHADOW_URL=http%3A//pr-url.com/repository']),
 ])
 def test_webook_parse_url_for_pull_request_event(base_data, template, expected_urls):
 
     base_data['pullrequest'] = {
         'pull_request_id': 999,
         'url': 'http://pr-url.com',
         'title': 'example-pr-title Ticket #123',
         'commits_uid': 'abcdefg1234',
         'shadow_url': 'http://pr-url.com/repository'
     }
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(events.PullRequestCreateEvent(
         AttributeDict({'target_repo': 'foo'})), base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${branch}/build',
         ['http://server.com/stable/build',
          'http://server.com/dev/build']),
     ('http://server.com/${branch}/${commit_id}',
         ['http://server.com/stable/stable-xxx',
          'http://server.com/stable/stable-yyy',
          'http://server.com/dev/dev-xxx',
          'http://server.com/dev/dev-yyy']),
     ('http://server.com/${branch_head}',
      ['http://server.com/stable-yyy',
       'http://server.com/dev-yyy']),
     ('http://server.com/${commit_id}',
      ['http://server.com/stable-xxx',
       'http://server.com/stable-yyy',
       'http://server.com/dev-xxx',
       'http://server.com/dev-yyy']),
 ])
 def test_webook_parse_url_for_push_event(
         baseapp, repo_push_event, base_data, template, expected_urls):
     base_data['push'] = {
         'branches': [{'name': 'stable'}, {'name': 'dev'}],
         'commits': [{'branch': 'stable', 'raw_id': 'stable-xxx'},
                     {'branch': 'stable', 'raw_id': 'stable-yyy'},
                     {'branch': 'dev', 'raw_id': 'dev-xxx'},
                     {'branch': 'dev', 'raw_id': 'dev-yyy'}]
     }
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(repo_push_event, base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]

rhodecode/tests/lib/auth_modules/test_auth_modules.py

@@ -1,189 +1,189 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 from rhodecode.lib.auth import _RhodeCodeCryptoBCrypt
 from rhodecode.authentication.base import RhodeCodeAuthPluginBase
 from rhodecode.authentication.plugins.auth_ldap import RhodeCodeAuthPlugin
 from rhodecode.model import db
 
 
 class RcTestAuthPlugin(RhodeCodeAuthPluginBase):
 
     def name(self):
         return u'stub_auth'
 
 
 def test_authenticate_returns_from_auth(stub_auth_data):
     plugin = RcTestAuthPlugin('stub_id')
     with mock.patch.object(plugin, 'auth') as auth_mock:
         auth_mock.return_value = stub_auth_data
         result = plugin._authenticate(mock.Mock(), 'test', 'password', {})
     assert stub_auth_data == result
 
 
 def test_authenticate_returns_empty_auth_data():
     auth_data = {}
     plugin = RcTestAuthPlugin('stub_id')
     with mock.patch.object(plugin, 'auth') as auth_mock:
         auth_mock.return_value = auth_data
         result = plugin._authenticate(mock.Mock(), 'test', 'password', {})
     assert auth_data == result
 
 
 def test_authenticate_skips_hash_migration_if_mismatch(stub_auth_data):
     stub_auth_data['_hash_migrate'] = 'new-hash'
     plugin = RcTestAuthPlugin('stub_id')
     with mock.patch.object(plugin, 'auth') as auth_mock:
         auth_mock.return_value = stub_auth_data
         result = plugin._authenticate(mock.Mock(), 'test', 'password', {})
 
     user = db.User.get_by_username(stub_auth_data['username'])
     assert user.password != 'new-hash'
     assert result == stub_auth_data
 
 
 def test_authenticate_migrates_to_new_hash(stub_auth_data):
     new_password = b'new-password'
     new_hash = _RhodeCodeCryptoBCrypt().hash_create(new_password)
     stub_auth_data['_hash_migrate'] = new_hash
     plugin = RcTestAuthPlugin('stub_id')
     with mock.patch.object(plugin, 'auth') as auth_mock:
         auth_mock.return_value = stub_auth_data
         result = plugin._authenticate(
             mock.Mock(), stub_auth_data['username'], new_password, {})
 
     user = db.User.get_by_username(stub_auth_data['username'])
     assert user.password == new_hash
     assert result == stub_auth_data
 
 
[e-mail]
[e-mail]()
 def stub_auth_data(user_util):
     user = user_util.create_user()
     data = {
         'username': user.username,
         'password': 'password',
         'email': '[e-mail]',
         'firstname': 'John',
         'lastname': 'Smith',
         'groups': [],
         'active': True,
         'admin': False,
         'extern_name': 'test',
         'extern_type': 'ldap',
         'active_from_extern': True
     }
     return data
 
 
 class TestRhodeCodeAuthPlugin(object):
     def setup_method(self, method):
         self.finalizers = []
         self.user = mock.Mock()
         self.user.username = 'test'
         self.user.password = 'old-password'
         self.fake_auth = {
             'username': 'test',
             'password': 'test',
             'email': '[e-mail]',
             'firstname': 'John',
             'lastname': 'Smith',
             'groups': [],
             'active': True,
             'admin': False,
             'extern_name': 'test',
             'extern_type': 'ldap',
             'active_from_extern': True
         }
 
     def teardown_method(self, method):
         if self.finalizers:
             for finalizer in self.finalizers:
                 finalizer()
             self.finalizers = []
 
     def test_fake_password_is_created_for_the_new_user(self):
         self._patch()
         auth_plugin = RhodeCodeAuthPlugin('stub_id')
         auth_plugin._authenticate(self.user, 'test', 'test', [])
         self.password_generator_mock.assert_called_once_with(length=16)
         create_user_kwargs = self.create_user_mock.call_args[1]
         assert create_user_kwargs['password'] == 'new-password'
 
     def test_fake_password_is_not_created_for_the_existing_user(self):
         self._patch()
         self.get_user_mock.return_value = self.user
         auth_plugin = RhodeCodeAuthPlugin('stub_id')
         auth_plugin._authenticate(self.user, 'test', 'test', [])
         assert self.password_generator_mock.called is False
         create_user_kwargs = self.create_user_mock.call_args[1]
         assert create_user_kwargs['password'] == self.user.password
 
     def _patch(self):
         get_user_patch = mock.patch('rhodecode.model.db.User.get_by_username')
         self.get_user_mock = get_user_patch.start()
         self.get_user_mock.return_value = None
         self.finalizers.append(get_user_patch.stop)
 
         create_user_patch = mock.patch(
             'rhodecode.model.user.UserModel.create_or_update')
         self.create_user_mock = create_user_patch.start()
         self.create_user_mock.return_value = None
         self.finalizers.append(create_user_patch.stop)
 
         auth_patch = mock.patch.object(RhodeCodeAuthPlugin, 'auth')
         self.auth_mock = auth_patch.start()
         self.auth_mock.return_value = self.fake_auth
         self.finalizers.append(auth_patch.stop)
 
         password_generator_patch = mock.patch(
             'rhodecode.lib.auth.PasswordGenerator.gen_password')
         self.password_generator_mock = password_generator_patch.start()
         self.password_generator_mock.return_value = 'new-password'
         self.finalizers.append(password_generator_patch.stop)
 
 
 def test_missing_ldap():
     from rhodecode.model.validators import Missing
 
     try:
         import ldap_not_existing
     except ImportError:
         # means that python-ldap is not installed
         ldap_not_existing = Missing
 
     # missing is singleton
     assert ldap_not_existing == Missing
 
 
 def test_import_ldap():
     from rhodecode.model.validators import Missing
 
     try:
         import ldap
     except ImportError:
         # means that python-ldap is not installed
         ldap = Missing
 
     # missing is singleton
     assert False is (ldap == Missing)

rhodecode/tests/lib/middleware/test_simplevcs.py

@@ -1,473 +1,473 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import base64
 
 import mock
 import pytest
 
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.tests.utils import CustomTestApp
 
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.hooks_daemon import DummyHooksCallbackDaemon
 from rhodecode.lib.middleware import simplevcs
 from rhodecode.lib.middleware.https_fixup import HttpsFixup
 from rhodecode.lib.middleware.utils import scm_app_http
 from rhodecode.model.db import User, _hash_key
 from rhodecode.model.meta import Session
 from rhodecode.tests import (
     HG_REPO, TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
 from rhodecode.tests.lib.middleware import mock_scm_app
 
 
 class StubVCSController(simplevcs.SimpleVCS):
 
     SCM = 'hg'
     stub_response_body = tuple()
 
     def __init__(self, *args, **kwargs):
         super(StubVCSController, self).__init__(*args, **kwargs)
         self._action = 'pull'
         self._is_shadow_repo_dir = True
         self._name = HG_REPO
         self.set_repo_names(None)
 
     @property
     def is_shadow_repo_dir(self):
         return self._is_shadow_repo_dir
 
     def _get_repository_name(self, environ):
         return self._name
 
     def _get_action(self, environ):
         return self._action
 
     def _create_wsgi_app(self, repo_path, repo_name, config):
         def fake_app(environ, start_response):
             headers = [
                 ('Http-Accept', 'application/mercurial')
             ]
             start_response('200 OK', headers)
             return self.stub_response_body
         return fake_app
 
     def _create_config(self, extras, repo_name, scheme='http'):
         return None
 
 
[e-mail]
[e-mail]()
 def vcscontroller(baseapp, config_stub, request_stub):
     config_stub.testing_securitypolicy()
     config_stub.include('rhodecode.authentication')
     config_stub.include('rhodecode.authentication.plugins.auth_rhodecode')
     config_stub.include('rhodecode.authentication.plugins.auth_token')
 
     controller = StubVCSController(
         baseapp.config.get_settings(), request_stub.registry)
     app = HttpsFixup(controller, baseapp.config.get_settings())
     app = CustomTestApp(app)
 
     _remove_default_user_from_query_cache()
 
     # Sanity checks that things are set up correctly
     app.get('/' + HG_REPO, status=200)
 
     app.controller = controller
     return app
 
 
 def _remove_default_user_from_query_cache():
     user = User.get_default_user(cache=True)
     query = Session().query(User).filter(User.username == user.username)
     query = query.options(
         FromCache("sql_cache_short", "get_user_%s" % _hash_key(user.username)))
     query.invalidate()
     Session().expire(user)
 
 
 def test_handles_exceptions_during_permissions_checks(
         vcscontroller, disable_anonymous_user):
     user_and_pass = '%s:%s' % (TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
     auth_password = base64.encodestring(user_and_pass).strip()
     extra_environ = {
         'AUTH_TYPE': 'Basic',
         'HTTP_AUTHORIZATION': 'Basic %s' % auth_password,
         'REMOTE_USER': TEST_USER_ADMIN_LOGIN,
     }
 
     # Verify that things are hooked up correctly
     vcscontroller.get('/', status=200, extra_environ=extra_environ)
 
     # Simulate trouble during permission checks
     with mock.patch('rhodecode.model.db.User.get_by_username',
                     side_effect=Exception) as get_user:
         # Verify that a correct 500 is returned and check that the expected
         # code path was hit.
         vcscontroller.get('/', status=500, extra_environ=extra_environ)
         assert get_user.called
 
 
 def test_returns_forbidden_if_no_anonymous_access(
         vcscontroller, disable_anonymous_user):
     vcscontroller.get('/', status=401)
 
 
 class StubFailVCSController(simplevcs.SimpleVCS):
     def _handle_request(self, environ, start_response):
         raise Exception("BOOM")
 
 
 @pytest.fixture(scope='module')
 def fail_controller(baseapp):
     controller = StubFailVCSController(
         baseapp.config.get_settings(), baseapp.config)
     controller = HttpsFixup(controller, baseapp.config.get_settings())
     controller = CustomTestApp(controller)
     return controller
 
 
 def test_handles_exceptions_as_internal_server_error(fail_controller):
     fail_controller.get('/', status=500)
 
 
 def test_provides_traceback_for_appenlight(fail_controller):
     response = fail_controller.get(
         '/', status=500, extra_environ={'appenlight.client': 'fake'})
     assert 'appenlight.__traceback' in response.request.environ
 
 
 def test_provides_utils_scm_app_as_scm_app_by_default(baseapp, request_stub):
     controller = StubVCSController(baseapp.config.get_settings(), request_stub.registry)
     assert controller.scm_app is scm_app_http
 
 
 def test_allows_to_override_scm_app_via_config(baseapp, request_stub):
     config = baseapp.config.get_settings().copy()
     config['vcs.scm_app_implementation'] = (
         'rhodecode.tests.lib.middleware.mock_scm_app')
     controller = StubVCSController(config, request_stub.registry)
     assert controller.scm_app is mock_scm_app
 
 
 @pytest.mark.parametrize('query_string, expected', [
     ('cmd=stub_command', True),
     ('cmd=listkeys', False),
 ])
 def test_should_check_locking(query_string, expected):
     result = simplevcs._should_check_locking(query_string)
     assert result == expected
 
 
 class TestShadowRepoRegularExpression(object):
     pr_segment = 'pull-request'
     shadow_segment = 'repository'
 
     @pytest.mark.parametrize('url, expected', [
         # repo with/without groups
         ('My-Repo/{pr_segment}/1/{shadow_segment}', True),
         ('Group/My-Repo/{pr_segment}/2/{shadow_segment}', True),
         ('Group/Sub-Group/My-Repo/{pr_segment}/3/{shadow_segment}', True),
         ('Group/Sub-Group1/Sub-Group2/My-Repo/{pr_segment}/3/{shadow_segment}', True),
 
         # pull request ID
         ('MyRepo/{pr_segment}/1/{shadow_segment}', True),
         ('MyRepo/{pr_segment}/1234567890/{shadow_segment}', True),
         ('MyRepo/{pr_segment}/-1/{shadow_segment}', False),
         ('MyRepo/{pr_segment}/invalid/{shadow_segment}', False),
 
         # unicode
         (u'Sp€çîál-Repö/{pr_segment}/1/{shadow_segment}', True),
         (u'Sp€çîál-Gröüp/Sp€çîál-Repö/{pr_segment}/1/{shadow_segment}', True),
 
         # trailing/leading slash
         ('/My-Repo/{pr_segment}/1/{shadow_segment}', False),
         ('My-Repo/{pr_segment}/1/{shadow_segment}/', False),
         ('/My-Repo/{pr_segment}/1/{shadow_segment}/', False),
 
         # misc
         ('My-Repo/{pr_segment}/1/{shadow_segment}/extra', False),
         ('My-Repo/{pr_segment}/1/{shadow_segment}extra', False),
     ])
     def test_shadow_repo_regular_expression(self, url, expected):
         from rhodecode.lib.middleware.simplevcs import SimpleVCS
         url = url.format(
             pr_segment=self.pr_segment,
             shadow_segment=self.shadow_segment)
         match_obj = SimpleVCS.shadow_repo_re.match(url)
         assert (match_obj is not None) == expected
 
 
 @pytest.mark.backends('git', 'hg')
 class TestShadowRepoExposure(object):
 
     def test_pull_on_shadow_repo_propagates_to_wsgi_app(
             self, baseapp, request_stub):
         """
         Check that a pull action to a shadow repo is propagated to the
         underlying wsgi app.
         """
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._check_ssl = mock.Mock()
         controller.is_shadow_repo = True
         controller._action = 'pull'
         controller._is_shadow_repo_dir = True
         controller.stub_response_body = 'dummy body value'
         controller._get_default_cache_ttl = mock.Mock(
             return_value=(False, 0))
 
         environ_stub = {
             'HTTP_HOST': 'test.example.com',
             'HTTP_ACCEPT': 'application/mercurial',
             'REQUEST_METHOD': 'GET',
             'wsgi.url_scheme': 'http',
         }
 
         response = controller(environ_stub, mock.Mock())
         response_body = ''.join(response)
 
         # Assert that we got the response from the wsgi app.
         assert response_body == controller.stub_response_body
 
     def test_pull_on_shadow_repo_that_is_missing(self, baseapp, request_stub):
         """
         Check that a pull action to a shadow repo is propagated to the
         underlying wsgi app.
         """
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._check_ssl = mock.Mock()
         controller.is_shadow_repo = True
         controller._action = 'pull'
         controller._is_shadow_repo_dir = False
         controller.stub_response_body = 'dummy body value'
         environ_stub = {
             'HTTP_HOST': 'test.example.com',
             'HTTP_ACCEPT': 'application/mercurial',
             'REQUEST_METHOD': 'GET',
             'wsgi.url_scheme': 'http',
         }
 
         response = controller(environ_stub, mock.Mock())
         response_body = ''.join(response)
 
         # Assert that we got the response from the wsgi app.
         assert '404 Not Found' in response_body
 
     def test_push_on_shadow_repo_raises(self, baseapp, request_stub):
         """
         Check that a push action to a shadow repo is aborted.
         """
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._check_ssl = mock.Mock()
         controller.is_shadow_repo = True
         controller._action = 'push'
         controller.stub_response_body = 'dummy body value'
         environ_stub = {
             'HTTP_HOST': 'test.example.com',
             'HTTP_ACCEPT': 'application/mercurial',
             'REQUEST_METHOD': 'GET',
             'wsgi.url_scheme': 'http',
         }
 
         response = controller(environ_stub, mock.Mock())
         response_body = ''.join(response)
 
         assert response_body != controller.stub_response_body
         # Assert that a 406 error is returned.
         assert '406 Not Acceptable' in response_body
 
     def test_set_repo_names_no_shadow(self, baseapp, request_stub):
         """
         Check that the set_repo_names method sets all names to the one returned
         by the _get_repository_name method on a request to a non shadow repo.
         """
         environ_stub = {}
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._name = 'RepoGroup/MyRepo'
         controller.set_repo_names(environ_stub)
         assert not controller.is_shadow_repo
         assert (controller.url_repo_name ==
                 controller.acl_repo_name ==
                 controller.vcs_repo_name ==
                 controller._get_repository_name(environ_stub))
 
     def test_set_repo_names_with_shadow(
             self, baseapp, pr_util, config_stub, request_stub):
         """
         Check that the set_repo_names method sets correct names on a request
         to a shadow repo.
         """
         from rhodecode.model.pull_request import PullRequestModel
 
         pull_request = pr_util.create_pull_request()
         shadow_url = '{target}/{pr_segment}/{pr_id}/{shadow_segment}'.format(
             target=pull_request.target_repo.repo_name,
             pr_id=pull_request.pull_request_id,
             pr_segment=TestShadowRepoRegularExpression.pr_segment,
             shadow_segment=TestShadowRepoRegularExpression.shadow_segment)
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._name = shadow_url
         controller.set_repo_names({})
 
         # Get file system path to shadow repo for assertions.
         workspace_id = PullRequestModel()._workspace_id(pull_request)
         vcs_repo_name = pull_request.target_repo.get_shadow_repository_path(workspace_id)
 
         assert controller.vcs_repo_name == vcs_repo_name
         assert controller.url_repo_name == shadow_url
         assert controller.acl_repo_name == pull_request.target_repo.repo_name
         assert controller.is_shadow_repo
 
     def test_set_repo_names_with_shadow_but_missing_pr(
             self, baseapp, pr_util, config_stub, request_stub):
         """
         Checks that the set_repo_names method enforces matching target repos
         and pull request IDs.
         """
         pull_request = pr_util.create_pull_request()
         shadow_url = '{target}/{pr_segment}/{pr_id}/{shadow_segment}'.format(
             target=pull_request.target_repo.repo_name,
             pr_id=999999999,
             pr_segment=TestShadowRepoRegularExpression.pr_segment,
             shadow_segment=TestShadowRepoRegularExpression.shadow_segment)
         controller = StubVCSController(
             baseapp.config.get_settings(), request_stub.registry)
         controller._name = shadow_url
         controller.set_repo_names({})
 
         assert not controller.is_shadow_repo
         assert (controller.url_repo_name ==
                 controller.acl_repo_name ==
                 controller.vcs_repo_name)
 
 
 @pytest.mark.usefixtures('baseapp')
 class TestGenerateVcsResponse(object):
 
     def test_ensures_that_start_response_is_called_early_enough(self):
         self.call_controller_with_response_body(iter(['a', 'b']))
         assert self.start_response.called
 
     def test_invalidates_cache_after_body_is_consumed(self):
         result = self.call_controller_with_response_body(iter(['a', 'b']))
         assert not self.was_cache_invalidated()
         # Consume the result
         list(result)
         assert self.was_cache_invalidated()
 
     def test_raises_unknown_exceptions(self):
         result = self.call_controller_with_response_body(
             self.raise_result_iter(vcs_kind='unknown'))
         with pytest.raises(Exception):
             list(result)
 
     def test_prepare_callback_daemon_is_called(self):
         def side_effect(extras, environ, action, txn_id=None):
             return DummyHooksCallbackDaemon(), extras
 
         prepare_patcher = mock.patch.object(
             StubVCSController, '_prepare_callback_daemon')
         with prepare_patcher as prepare_mock:
             prepare_mock.side_effect = side_effect
             self.call_controller_with_response_body(iter(['a', 'b']))
         assert prepare_mock.called
         assert prepare_mock.call_count == 1
 
     def call_controller_with_response_body(self, response_body):
         settings = {
             'base_path': 'fake_base_path',
             'vcs.hooks.protocol': 'http',
             'vcs.hooks.direct_calls': False,
         }
         registry = AttributeDict()
         controller = StubVCSController(settings, registry)
         controller._invalidate_cache = mock.Mock()
         controller.stub_response_body = response_body
         self.start_response = mock.Mock()
         result = controller._generate_vcs_response(
             environ={}, start_response=self.start_response,
             repo_path='fake_repo_path',
             extras={}, action='push')
         self.controller = controller
         return result
 
     def raise_result_iter(self, vcs_kind='repo_locked'):
         """
         Simulates an exception due to a vcs raised exception if kind vcs_kind
         """
         raise self.vcs_exception(vcs_kind=vcs_kind)
         yield "never_reached"
 
     def vcs_exception(self, vcs_kind='repo_locked'):
         locked_exception = Exception('TEST_MESSAGE')
         locked_exception._vcs_kind = vcs_kind
         return locked_exception
 
     def was_cache_invalidated(self):
         return self.controller._invalidate_cache.called
 
 
 class TestInitializeGenerator(object):
 
     def test_drains_first_element(self):
         gen = self.factory(['__init__', 1, 2])
         result = list(gen)
         assert result == [1, 2]
 
     @pytest.mark.parametrize('values', [
         [],
         [1, 2],
     ])
     def test_raises_value_error(self, values):
         with pytest.raises(ValueError):
             self.factory(values)
 
     @simplevcs.initialize_generator
     def factory(self, iterable):
         for elem in iterable:
             yield elem
 
 
 class TestPrepareHooksDaemon(object):
     def test_calls_imported_prepare_callback_daemon(self, app_settings, request_stub):
         expected_extras = {'extra1': 'value1'}
         daemon = DummyHooksCallbackDaemon()
 
         controller = StubVCSController(app_settings, request_stub.registry)
         prepare_patcher = mock.patch.object(
             simplevcs, 'prepare_callback_daemon',
             return_value=(daemon, expected_extras))
         with prepare_patcher as prepare_mock:
             callback_daemon, extras = controller._prepare_callback_daemon(
                 expected_extras.copy(), {}, 'push')
         prepare_mock.assert_called_once_with(
             expected_extras,
             protocol=app_settings['vcs.hooks.protocol'],
             host=app_settings['vcs.hooks.host'],
             txn_id=None,
             use_direct_calls=app_settings['vcs.hooks.direct_calls'])
 
         assert callback_daemon == daemon
         assert extras == extras

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

@@ -1,136 +1,136 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Checking the chunked data transfer via HTTP
 """
 
 import os
 import time
 import subprocess32
 
 import pytest
 import requests
 
 from rhodecode.lib.middleware.utils import scm_app_http
 from rhodecode.tests.utils import wait_for_url
 
 
 def test_does_chunked_end_to_end_transfer(scm_app):
     response = requests.post(scm_app, data='', stream=True)
     assert response.headers['Transfer-Encoding'] == 'chunked'
     times = [time.time() for chunk in response.raw.read_chunked()]
     assert times[1] - times[0] > 0.1, "Chunks arrived at the same time"
 
 
[e-mail]
[e-mail]()
 def echo_app_chunking(request, available_port_factory):
     """
     Run the EchoApp via Waitress in a subprocess.
 
     Return the URL endpoint to reach the app.
     """
     port = available_port_factory()
     command = (
         'waitress-serve --send-bytes 1 --port {port} --call '
         'rhodecode.tests.lib.middleware.utils.test_scm_app_http_chunking'
         ':create_echo_app')
     command = command.format(port=port)
     proc = subprocess32.Popen(command.split(' '), bufsize=0)
     echo_app_url = 'http://localhost:' + str(port)
 
     @request.addfinalizer
     def stop_echo_app():
         proc.kill()
 
     return echo_app_url
 
 
[e-mail]
[e-mail]()
 def scm_app(request, available_port_factory, echo_app_chunking):
     """
     Run the scm_app in Waitress.
 
     Returns the URL endpoint where this app can be reached.
     """
     port = available_port_factory()
     command = (
         'waitress-serve --send-bytes 1 --port {port} --call '
         'rhodecode.tests.lib.middleware.utils.test_scm_app_http_chunking'
         ':create_scm_app')
     command = command.format(port=port)
     env = os.environ.copy()
     env["RC_ECHO_URL"] = echo_app_chunking
     proc = subprocess32.Popen(command.split(' '), bufsize=0, env=env)
     scm_app_url = 'http://localhost:' + str(port)
     wait_for_url(scm_app_url)
 
     @request.addfinalizer
     def stop_echo_app():
         proc.kill()
 
     return scm_app_url
 
 
 class EchoApp(object):
     """
     Stub WSGI application which returns a chunked response to every request.
     """
 
     def __init__(self, repo_path, repo_name, config):
         self._repo_path = repo_path
 
     def __call__(self, environ, start_response):
         environ['wsgi.input'].read()
         status = '200 OK'
         headers = []
         start_response(status, headers)
         return result_generator()
 
 
 def result_generator():
     """
     Simulate chunked results.
 
     The intended usage is to simulate a chunked response as we would get it
     out of a vcs operation during a call to "hg clone".
     """
     yield 'waiting 2 seconds'
     # Wait long enough so that the first chunk can go out
     time.sleep(2)
     yield 'final chunk'
     # Another small wait, otherwise they go together
     time.sleep(0.1)
 
 
 def create_echo_app():
     """
     Create EchoApp filled with stub data.
     """
     return EchoApp('stub_path', 'repo_name', {})
 
 
 def create_scm_app():
     """
     Create a scm_app hooked up to speak to EchoApp.
     """
     echo_app_url = os.environ["RC_ECHO_URL"]
     return scm_app_http.VcsHttpProxy(
         echo_app_url, 'stub_path', 'stub_name', None)

rhodecode/tests/lib/test_auth_crypto_backend.py

@@ -1,101 +1,101 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Tests checking the crypto backends which can be used by lib/auth.
 """
 import collections
 
 import pytest
 
 from rhodecode.lib import auth
 
 
 # Utility functions to get or check passwords
 
 def test_get_crypt_password_accepts_unicode(password):
     result = auth.get_crypt_password(password.value)
     assert result == password.hashed
 
 
 def test_check_password_accepts_unicode(password):
     result = auth.check_password(password.value, password.hashed)
     assert result
 
 
 # API contracts from _RhodeCodeCryptoBase
 
 def test_constructor_takes_no_arguments(crypto_backend_class):
     instance = crypto_backend_class()
     assert instance
 
 
 def test_hash_create_returns_bytes(crypto_backend, password):
     hashed = crypto_backend.hash_create(password.encoded)
     assert isinstance(hashed, str)
 
 
 def test_hash_create_changes_the_value(crypto_backend, password):
     hashed = crypto_backend.hash_create(password.encoded)
     assert hashed != password.encoded
 
 
 def test_hash_create_enforces_bytes(crypto_backend, password):
     with pytest.raises(TypeError):
         crypto_backend.hash_create(password.value)
 
 
 def test_hash_check(crypto_backend, password):
     not_matching = 'stub-hash'
     with pytest.raises(TypeError):
         crypto_backend.hash_check(password.value, not_matching)
 
 
 def test_hash_check_with_update_enforces_bytes(crypto_backend, password):
     not_matching = 'stub-hash'
     with pytest.raises(TypeError):
         crypto_backend.hash_check_with_upgrade(password.value, not_matching)
 
 
 @pytest.fixture(params=[
     auth._RhodeCodeCryptoTest,
     auth._RhodeCodeCryptoBCrypt,
     auth._RhodeCodeCryptoSha256,
 ])
 def crypto_backend_class(request):
     """
     Parameterizes per crypto backend class.
     """
     return request.param
 
 
[e-mail]
[e-mail]()
 def crypto_backend(crypto_backend_class):
     return crypto_backend_class()
 
 
[e-mail]
[e-mail]()
 def password():
     encoding = 'utf-8'
     value = u'value'
     value_encoded = value.encode(encoding)
     value_hashed = auth.crypto_backend().hash_create(value_encoded)
     return collections.namedtuple('Password', 'value, encoded, hashed')(
         value, value_encoded, value_hashed)

rhodecode/tests/lib/test_db_manage.py

@@ -1,92 +1,92 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 from rhodecode.lib.db_manage import DbManage
 from rhodecode.model import db
 
 
[e-mail]
[e-mail]()
 def db_manage(baseapp):
     db_manage = DbManage(
         log_sql=True, dbconf='fake', root='fake', tests=False,
         cli_args={}, SESSION=db.Session())
     return db_manage
 
 
 @pytest.fixture(autouse=True)
 def session_rollback(baseapp, request):
     """
     Rollback the database session after the test run.
 
     Intended usage is for tests wich mess with the database but don't
     commit. In this case a rollback after the test run will leave the database
     in a clean state.
 
     This is still a workaround until we find a way to isolate the tests better
     from each other.
     """
     @request.addfinalizer
     def cleanup():
         db.Session().rollback()
 
 
 def test_create_admin_and_prompt_uses_getpass(db_manage):
     db_manage.cli_args = {
         'username': 'test',
         'email': '[e-mail]'}
     with mock.patch('getpass.getpass', return_value='password') as getpass:
         db_manage.create_admin_and_prompt()
     assert getpass.called
 
 
 def test_create_admin_and_prompt_sets_the_api_key(db_manage):
     db_manage.cli_args = {
         'username': 'test',
         'password': 'testpassword',
         'email': '[e-mail]',
         'api_key': 'testkey'}
     with mock.patch.object(db_manage, 'create_user') as create_user:
         db_manage.create_admin_and_prompt()
 
     assert create_user.call_args[1]['api_key'] == 'testkey'
 
 
 @pytest.mark.parametrize('add_keys', [True, False])
 def test_create_user_sets_the_api_key(db_manage, add_keys):
     username = 'test_add_keys_{}'.format(add_keys)
     db_manage.create_user(
         username, 'testpassword', '[e-mail]',
         api_key=add_keys)
 
     user = db.User.get_by_username(username)
     if add_keys:
         assert 2 == len(user.auth_tokens)
     else:
         # only feed token
         assert 1 == len(user.auth_tokens)
 
 
 def test_create_user_without_api_key(db_manage):
     db_manage.create_user('test', 'testpassword', '[e-mail]')
     user = db.User.get_by_username('test')
     assert user.api_key is None

rhodecode/tests/lib/test_diffs.py

@@ -1,825 +1,825 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import textwrap
 
 import mock
 import pytest
 
 from rhodecode.lib.codeblocks import DiffSet
 from rhodecode.lib.diffs import (
     DiffProcessor,
     NEW_FILENODE, DEL_FILENODE, MOD_FILENODE, RENAMED_FILENODE,
     CHMOD_FILENODE, BIN_FILENODE, COPIED_FILENODE)
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.lib.vcs.backends.git import GitCommit
 from rhodecode.tests.fixture import Fixture, no_newline_id_generator
 from rhodecode.lib.vcs.backends.git.repository import GitDiff
 from rhodecode.lib.vcs.backends.hg.repository import MercurialDiff
 from rhodecode.lib.vcs.backends.svn.repository import SubversionDiff
 
 fixture = Fixture()
 
 
 def test_diffprocessor_as_html_with_comments():
     raw_diff = textwrap.dedent('''
         diff --git a/setup.py b/setup.py
         index 5b36422..cfd698e 100755
         --- a/setup.py
         +++ b/setup.py
         @@ -2,7 +2,7 @@
          #!/usr/bin/python
          # Setup file for X
          # Copyright (C) No one
         -
         +x
          try:
              from setuptools import setup, Extension
          except ImportError:
     ''')
     diff = GitDiff(raw_diff)
     processor = DiffProcessor(diff)
     processor.prepare()
 
     # Note that the cell with the context in line 5 (in the html) has the
     # no-comment class, which will prevent the add comment icon to be displayed.
     expected_html = textwrap.dedent('''
         <table class="code-difftable">
         <tr class="line context">
             <td class="add-comment-line"><span class="add-comment-content"></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td  class="lineno old">...</td>
             <td  class="lineno new">...</td>
             <td class="code no-comment">
                 <pre>@@ -2,7 +2,7 @@
         </pre>
             </td>
         </tr>
         <tr class="line unmod">
             <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o2" class="lineno old"><a href="#setuppy_o2" class="tooltip"
                         title="Click to select line">2</a></td>
             <td id="setuppy_n2" class="lineno new"><a href="#setuppy_n2" class="tooltip"
                         title="Click to select line">2</a></td>
             <td class="code">
                 <pre>#!/usr/bin/python
         </pre>
             </td>
         </tr>
         <tr class="line unmod">
             <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o3" class="lineno old"><a href="#setuppy_o3" class="tooltip"
                         title="Click to select line">3</a></td>
             <td id="setuppy_n3" class="lineno new"><a href="#setuppy_n3" class="tooltip"
                         title="Click to select line">3</a></td>
             <td class="code">
                 <pre># Setup file for X
         </pre>
             </td>
         </tr>
         <tr class="line unmod">
             <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o4" class="lineno old"><a href="#setuppy_o4" class="tooltip"
                         title="Click to select line">4</a></td>
             <td id="setuppy_n4" class="lineno new"><a href="#setuppy_n4" class="tooltip"
                         title="Click to select line">4</a></td>
             <td class="code">
                 <pre># Copyright (C) No one
         </pre>
             </td>
         </tr>
         <tr class="line del">
             <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o5" class="lineno old"><a href="#setuppy_o5" class="tooltip"
                         title="Click to select line">5</a></td>
             <td  class="lineno new"><a href="#setuppy_n" class="tooltip"
                         title="Click to select line"></a></td>
             <td class="code">
                 <pre>
         </pre>
             </td>
         </tr>
         <tr class="line add">
             <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td  class="lineno old"><a href="#setuppy_o" class="tooltip"
                         title="Click to select line"></a></td>
             <td id="setuppy_n5" class="lineno new"><a href="#setuppy_n5" class="tooltip"
                         title="Click to select line">5</a></td>
             <td class="code">
                 <pre><ins>x</ins>
         </pre>
             </td>
         </tr>
         <tr class="line unmod">
             <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o6" class="lineno old"><a href="#setuppy_o6" class="tooltip"
                         title="Click to select line">6</a></td>
             <td id="setuppy_n6" class="lineno new"><a href="#setuppy_n6" class="tooltip"
                         title="Click to select line">6</a></td>
             <td class="code">
                 <pre>try:
         </pre>
             </td>
         </tr>
         <tr class="line unmod">
             <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o7" class="lineno old"><a href="#setuppy_o7" class="tooltip"
                         title="Click to select line">7</a></td>
             <td id="setuppy_n7" class="lineno new"><a href="#setuppy_n7" class="tooltip"
                         title="Click to select line">7</a></td>
             <td class="code">
                 <pre>    from setuptools import setup, Extension
         </pre>
             </td>
         </tr>
         <tr class="line unmod">
             <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td><td class="comment-toggle tooltip" title="Toggle Comment Thread"><i class="icon-comment"></i></td>
             <td id="setuppy_o8" class="lineno old"><a href="#setuppy_o8" class="tooltip"
                         title="Click to select line">8</a></td>
             <td id="setuppy_n8" class="lineno new"><a href="#setuppy_n8" class="tooltip"
                         title="Click to select line">8</a></td>
             <td class="code">
                 <pre>except ImportError:
         </pre>
             </td>
         </tr>
         </table>
     ''').strip()
     html = processor.as_html(enable_comments=True).replace('\t', '    ')
 
     assert html == expected_html
 
 
 class TestMixedFilenameEncodings(object):
 
     @pytest.fixture(scope="class")
     def raw_diff(self):
         return fixture.load_resource(
             'hg_diff_mixed_filename_encodings.diff')
 
-    @pytest.fixture
+    @pytest.fixture()
     def processor(self, raw_diff):
         diff = MercurialDiff(raw_diff)
         processor = DiffProcessor(diff)
         return processor
 
     def test_filenames_are_decoded_to_unicode(self, processor):
         diff_data = processor.prepare()
         filenames = [item['filename'] for item in diff_data]
         assert filenames == [
             u'späcial-utf8.txt', u'sp�cial-cp1252.txt', u'sp�cial-latin1.txt']
 
     def test_raw_diff_is_decoded_to_unicode(self, processor):
         diff_data = processor.prepare()
         raw_diffs = [item['raw_diff'] for item in diff_data]
         new_file_message = u'\nnew file mode 100644\n'
         expected_raw_diffs = [
             u' a/späcial-utf8.txt b/späcial-utf8.txt' + new_file_message,
             u' a/sp�cial-cp1252.txt b/sp�cial-cp1252.txt' + new_file_message,
             u' a/sp�cial-latin1.txt b/sp�cial-latin1.txt' + new_file_message]
         assert raw_diffs == expected_raw_diffs
 
     def test_as_raw_preserves_the_encoding(self, processor, raw_diff):
         assert processor.as_raw() == raw_diff
 
 
 # TODO: mikhail: format the following data structure properly
 DIFF_FIXTURES = [
     ('hg',
      'hg_diff_add_single_binary_file.diff',
      [('US Warszawa.jpg', 'A',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {NEW_FILENODE: 'new file 100755',
                 BIN_FILENODE: 'binary diff hidden'}}),
       ]),
     ('hg',
      'hg_diff_mod_single_binary_file.diff',
      [('US Warszawa.jpg', 'M',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {MOD_FILENODE: 'modified file',
                 BIN_FILENODE: 'binary diff hidden'}}),
       ]),
     ('hg',
      'hg_diff_mod_single_file_and_rename_and_chmod.diff',
      [('README', 'M',
        {'added': 3,
         'deleted': 0,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file',
                 RENAMED_FILENODE: 'file renamed from README.rst to README',
                 CHMOD_FILENODE: 'modified file chmod 100755 => 100644'}}),
       ]),
     ('hg',
      'hg_diff_no_newline.diff',
      [('server.properties', 'M',
        {'added': 2,
         'deleted': 1,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ]),
     ('hg',
      'hg_diff_mod_file_and_rename.diff',
      [('README.rst', 'M',
        {'added': 3,
         'deleted': 0,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file',
                 RENAMED_FILENODE: 'file renamed from README to README.rst'}}),
       ]),
     ('hg',
      'hg_diff_del_single_binary_file.diff',
      [('US Warszawa.jpg', 'D',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {DEL_FILENODE: 'deleted file',
                 BIN_FILENODE: 'binary diff hidden'}}),
       ]),
     ('hg',
      'hg_diff_chmod_and_mod_single_binary_file.diff',
      [('gravatar.png', 'M',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {CHMOD_FILENODE: 'modified file chmod 100644 => 100755',
                 BIN_FILENODE: 'binary diff hidden'}}),
       ]),
     ('hg',
      'hg_diff_chmod.diff',
      [('file', 'M',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {CHMOD_FILENODE: 'modified file chmod 100755 => 100644'}}),
       ]),
     ('hg',
      'hg_diff_rename_file.diff',
      [('file_renamed', 'M',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {RENAMED_FILENODE: 'file renamed from file to file_renamed'}}),
       ]),
     ('hg',
      'hg_diff_rename_and_chmod_file.diff',
      [('README', 'M',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {CHMOD_FILENODE: 'modified file chmod 100644 => 100755',
                 RENAMED_FILENODE: 'file renamed from README.rst to README'}}),
       ]),
     ('hg',
      'hg_diff_binary_and_normal.diff',
      [('img/baseline-10px.png', 'A',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {NEW_FILENODE: 'new file 100644',
                 BIN_FILENODE: 'binary diff hidden'}}),
       ('js/jquery/hashgrid.js', 'A',
        {'added': 340,
         'deleted': 0,
         'binary': False,
         'ops': {NEW_FILENODE: 'new file 100755'}}),
       ('index.html', 'M',
        {'added': 3,
         'deleted': 2,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('less/docs.less', 'M',
        {'added': 34,
         'deleted': 0,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('less/scaffolding.less', 'M',
        {'added': 1,
         'deleted': 3,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('readme.markdown', 'M',
        {'added': 1,
         'deleted': 10,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('img/baseline-20px.png', 'D',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {DEL_FILENODE: 'deleted file',
                 BIN_FILENODE: 'binary diff hidden'}}),
       ('js/global.js', 'D',
        {'added': 0,
         'deleted': 75,
         'binary': False,
         'ops': {DEL_FILENODE: 'deleted file'}})
       ]),
     ('git',
      'git_diff_chmod.diff',
      [('work-horus.xls', 'M',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {CHMOD_FILENODE: 'modified file chmod 100644 => 100755'}})
       ]),
     ('git',
      'git_diff_js_chars.diff',
      [('\\"><img src=x onerror=prompt(0)>/\\"><img src=x onerror=prompt(1)>.txt', 'M',
        {'added': 1,
         'deleted': 0,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}})
       ]),
     ('git',
      'git_diff_rename_file.diff',
      [('file.xls', 'M',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {
             RENAMED_FILENODE: 'file renamed from work-horus.xls to file.xls'}})
       ]),
     ('git',
      'git_diff_mod_single_binary_file.diff',
      [('US Warszawa.jpg', 'M',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {MOD_FILENODE: 'modified file',
                 BIN_FILENODE: 'binary diff hidden'}})
       ]),
     ('git',
      'git_diff_binary_and_normal.diff',
      [('img/baseline-10px.png', 'A',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {NEW_FILENODE: 'new file 100644',
                 BIN_FILENODE: 'binary diff hidden'}}),
       ('js/jquery/hashgrid.js', 'A',
        {'added': 340,
         'deleted': 0,
         'binary': False,
         'ops': {NEW_FILENODE: 'new file 100755'}}),
       ('index.html', 'M',
        {'added': 3,
         'deleted': 2,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('less/docs.less', 'M',
        {'added': 34,
         'deleted': 0,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('less/scaffolding.less', 'M',
        {'added': 1,
         'deleted': 3,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('readme.markdown', 'M',
        {'added': 1,
         'deleted': 10,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('img/baseline-20px.png', 'D',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {DEL_FILENODE: 'deleted file',
                 BIN_FILENODE: 'binary diff hidden'}}),
       ('js/global.js', 'D',
        {'added': 0,
         'deleted': 75,
         'binary': False,
         'ops': {DEL_FILENODE: 'deleted file'}}),
       ]),
     ('hg',
      'diff_with_diff_data.diff',
      [('vcs/backends/base.py', 'M',
        {'added': 18,
         'deleted': 2,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('vcs/backends/git/repository.py', 'M',
        {'added': 46,
         'deleted': 15,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('vcs/backends/hg.py', 'M',
        {'added': 22,
         'deleted': 3,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('vcs/tests/test_git.py', 'M',
        {'added': 5,
         'deleted': 5,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ('vcs/tests/test_repository.py', 'M',
        {'added': 174,
         'deleted': 2,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}}),
       ]),
     ('hg',
      'hg_diff_copy_file.diff',
      [('file2', 'M',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {COPIED_FILENODE: 'file copied from file1 to file2'}}),
       ]),
     ('hg',
      'hg_diff_copy_and_modify_file.diff',
      [('file3', 'M',
        {'added': 1,
         'deleted': 0,
         'binary': False,
         'ops': {COPIED_FILENODE: 'file copied from file2 to file3',
                 MOD_FILENODE: 'modified file'}}),
       ]),
     ('hg',
      'hg_diff_copy_and_chmod_file.diff',
      [('file4', 'M',
        {'added': 0,
         'deleted': 0,
         'binary': True,
         'ops': {COPIED_FILENODE: 'file copied from file3 to file4',
                 CHMOD_FILENODE: 'modified file chmod 100644 => 100755'}}),
       ]),
     ('hg',
      'hg_diff_copy_chmod_and_edit_file.diff',
      [('file5', 'M',
        {'added': 2,
         'deleted': 1,
         'binary': False,
         'ops': {COPIED_FILENODE: 'file copied from file4 to file5',
                 CHMOD_FILENODE: 'modified file chmod 100755 => 100644',
                 MOD_FILENODE: 'modified file'}})]),
 
     # Diffs to validate rename and copy file with space in its name
     ('git',
      'git_diff_rename_file_with_spaces.diff',
      [('file_with_  two spaces.txt', 'M',
          {'added': 0,
           'deleted': 0,
           'binary': True,
           'ops': {
               RENAMED_FILENODE: (
                   'file renamed from file_with_ spaces.txt to file_with_ '
                   ' two spaces.txt')}
           }), ]),
     ('hg',
      'hg_diff_rename_file_with_spaces.diff',
      [('file_changed _.txt', 'M',
          {'added': 0,
           'deleted': 0,
           'binary': True,
           'ops': {
               RENAMED_FILENODE: (
                   'file renamed from file_ with update.txt to file_changed'
                   ' _.txt')}
           }), ]),
     ('hg',
      'hg_diff_copy_file_with_spaces.diff',
      [('file_copied_ with  spaces.txt', 'M',
          {'added': 0,
           'deleted': 0,
           'binary': True,
           'ops': {
               COPIED_FILENODE: (
                   'file copied from file_changed_without_spaces.txt to'
                   ' file_copied_ with  spaces.txt')}
           }),
       ]),
 
     # special signs from git
     ('git',
      'git_diff_binary_special_files.diff',
      [('css/_Icon\\r', 'A',
          {'added': 0,
           'deleted': 0,
           'binary': True,
           'ops': {NEW_FILENODE: 'new file 100644',
                   BIN_FILENODE: 'binary diff hidden'}
           }),
       ]),
     ('git',
      'git_diff_binary_special_files_2.diff',
      [('css/Icon\\r', 'A',
          {'added': 0,
           'deleted': 0,
           'binary': True,
           'ops': {NEW_FILENODE: 'new file 100644', }
           }),
       ]),
 
     ('svn',
      'svn_diff_binary_add_file.diff',
      [('intl.dll', 'A',
        {'added': 0,
         'deleted': 0,
         'binary': False,
         'ops': {NEW_FILENODE: 'new file 10644',
                 #TODO(Marcink): depends on binary detection on svn patches
                 # BIN_FILENODE: 'binary diff hidden'
                 }
         }),
       ]),
 
     ('svn',
      'svn_diff_multiple_changes.diff',
      [('trunk/doc/images/SettingsOverlay.png', 'M',
        {'added': 0,
         'deleted': 0,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file',
                 #TODO(Marcink): depends on binary detection on svn patches
                 # BIN_FILENODE: 'binary diff hidden'
                 }
         }),
       ('trunk/doc/source/de/tsvn_ch04.xml', 'M',
        {'added': 89,
         'deleted': 34,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}
         }),
       ('trunk/doc/source/en/tsvn_ch04.xml', 'M',
        {'added': 66,
         'deleted': 21,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}
         }),
       ('trunk/src/Changelog.txt', 'M',
        {'added': 2,
         'deleted': 0,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}
         }),
       ('trunk/src/Resources/TortoiseProcENG.rc', 'M',
        {'added': 19,
         'deleted': 13,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}
         }),
       ('trunk/src/TortoiseProc/SetOverlayPage.cpp', 'M',
        {'added': 16,
         'deleted': 1,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}
         }),
       ('trunk/src/TortoiseProc/SetOverlayPage.h', 'M',
        {'added': 3,
         'deleted': 0,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}
         }),
       ('trunk/src/TortoiseProc/resource.h', 'M',
        {'added': 2,
         'deleted': 0,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}
         }),
       ('trunk/src/TortoiseShell/ShellCache.h', 'M',
        {'added': 50,
         'deleted': 1,
         'binary': False,
         'ops': {MOD_FILENODE: 'modified file'}
         }),
       ]),
 
 ]
 
 DIFF_FIXTURES_WITH_CONTENT = [
     (
         'hg', 'hg_diff_single_file_change_newline.diff',
         [
             (
                 'file_b',  # filename
                 'A',  # change
                 {  # stats
                    'added': 1,
                    'deleted': 0,
                    'binary': False,
                    'ops': {NEW_FILENODE: 'new file 100644', }
                 },
                 '@@ -0,0 +1 @@\n+test_content b\n'  # diff
             ),
         ],
     ),
     (
         'hg', 'hg_diff_double_file_change_newline.diff',
         [
             (
                 'file_b',  # filename
                 'A',  # change
                 {  # stats
                    'added': 1,
                    'deleted': 0,
                    'binary': False,
                    'ops': {NEW_FILENODE: 'new file 100644', }
                 },
                 '@@ -0,0 +1 @@\n+test_content b\n'  # diff
             ),
             (
                 'file_c',  # filename
                 'A',  # change
                 {  # stats
                    'added': 1,
                    'deleted': 0,
                    'binary': False,
                    'ops': {NEW_FILENODE: 'new file 100644', }
                 },
                 '@@ -0,0 +1 @@\n+test_content c\n'  # diff
             ),
         ],
     ),
     (
         'hg', 'hg_diff_double_file_change_double_newline.diff',
         [
             (
                 'file_b',  # filename
                 'A',  # change
                 {  # stats
                    'added': 1,
                    'deleted': 0,
                    'binary': False,
                    'ops': {NEW_FILENODE: 'new file 100644', }
                 },
                 '@@ -0,0 +1 @@\n+test_content b\n\n'  # diff
             ),
             (
                 'file_c',  # filename
                 'A',  # change
                 {  # stats
                    'added': 1,
                    'deleted': 0,
                    'binary': False,
                    'ops': {NEW_FILENODE: 'new file 100644', }
                 },
                 '@@ -0,0 +1 @@\n+test_content c\n'  # diff
             ),
         ],
     ),
     (
         'hg', 'hg_diff_four_file_change_newline.diff',
         [
             (
                 'file',  # filename
                 'A',  # change
                 {  # stats
                    'added': 1,
                    'deleted': 0,
                    'binary': False,
                    'ops': {NEW_FILENODE: 'new file 100644', }
                 },
                 '@@ -0,0 +1,1 @@\n+file\n'  # diff
             ),
             (
                 'file2',  # filename
                 'A',  # change
                 {  # stats
                    'added': 1,
                    'deleted': 0,
                    'binary': False,
                    'ops': {NEW_FILENODE: 'new file 100644', }
                 },
                 '@@ -0,0 +1,1 @@\n+another line\n'  # diff
             ),
             (
                 'file3',  # filename
                 'A',  # change
                 {  # stats
                    'added': 1,
                    'deleted': 0,
                    'binary': False,
                    'ops': {NEW_FILENODE: 'new file 100644', }
                 },
                 '@@ -0,0 +1,1 @@\n+newline\n'  # diff
             ),
             (
                 'file4',  # filename
                 'A',  # change
                 {  # stats
                    'added': 1,
                    'deleted': 0,
                    'binary': False,
                    'ops': {NEW_FILENODE: 'new file 100644', }
                 },
                 '@@ -0,0 +1,1 @@\n+fil4\n\\ No newline at end of file'  # diff
             ),
         ],
     ),
 
 ]
 
 
 diff_class = {
     'git': GitDiff,
     'hg': MercurialDiff,
     'svn': SubversionDiff,
 }
 
 
 @pytest.fixture(params=DIFF_FIXTURES)
 def diff_fixture(request):
     vcs, diff_fixture, expected = request.param
     diff_txt = fixture.load_resource(diff_fixture)
     diff = diff_class[vcs](diff_txt)
     return diff, expected
 
 
 def test_diff_lib(diff_fixture):
     diff, expected_data = diff_fixture
     diff_proc = DiffProcessor(diff)
     diff_proc_d = diff_proc.prepare()
     data = [(x['filename'], x['operation'], x['stats']) for x in diff_proc_d]
     assert expected_data == data
 
 
 @pytest.fixture(params=DIFF_FIXTURES_WITH_CONTENT)
 def diff_fixture_w_content(request):
     vcs, diff_fixture, expected = request.param
     diff_txt = fixture.load_resource(diff_fixture)
     diff = diff_class[vcs](diff_txt)
     return diff, expected
 
 
 def test_diff_over_limit(request):
 
     diff_limit = 1024
     file_limit = 1024
 
     raw_diff = fixture.load_resource('large_diff.diff')
     vcs_diff = GitDiff(raw_diff)
     diff_processor = DiffProcessor(
         vcs_diff, format='newdiff', diff_limit=diff_limit, file_limit=file_limit,
         show_full_diff=False)
 
     _parsed = diff_processor.prepare()
 
     commit1 = GitCommit(repository=mock.Mock(), raw_id='abcdef12', idx=1)
     commit2 = GitCommit(repository=mock.Mock(), raw_id='abcdef34', idx=2)
 
     diffset = DiffSet(
         repo_name='repo_name',
         source_node_getter=lambda *a, **kw: AttributeDict({'commit': commit1}),
         target_node_getter=lambda *a, **kw: AttributeDict({'commit': commit2})
     )
 
     diffset = diffset.render_patchset(_parsed, commit1, commit2)
 
     assert len(diffset.files) == 2
     assert diffset.limited_diff is True
     assert diffset.files[0].patch['filename'] == 'example.go'
     assert diffset.files[0].limited_diff is True
 
     assert diffset.files[1].patch['filename'] == 'README.md'
     assert diffset.files[1].limited_diff is False
 
 
 def test_diff_lib_newlines(diff_fixture_w_content):
     diff, expected_data = diff_fixture_w_content
     diff_proc = DiffProcessor(diff)
     diff_proc_d = diff_proc.prepare()
     data = [(x['filename'], x['operation'], x['stats'], x['raw_diff'])
             for x in diff_proc_d]
     assert expected_data == data
 
 
 @pytest.mark.parametrize('input_str', [
     '',
     '\n',
     '\n\n',
     'First\n+second',
     'First\n+second\n',
 
     '\n\n\n Multi \n\n\n',
     '\n\n\n Multi beginning',
     'Multi end \n\n\n',
     'Multi end',
     '@@ -0,0 +1 @@\n+test_content \n\n b\n'
 ], ids=no_newline_id_generator)
 def test_splitlines(input_str):
     result = DiffProcessor.diff_splitter(input_str)
     assert list(result) == input_str.splitlines(True)

rhodecode/tests/lib/test_diffs_context.py

@@ -1,383 +1,383 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Tests of :mod:`rhodecode.lib.diffs` around the context of a specific line.
 """
 
 import textwrap
 
 import pytest
 
 from rhodecode.lib import diffs
 from rhodecode.lib.vcs.backends.git.diff import GitDiff
 
 
 def test_context_of_new_and_old_line_number_raises(diff_processor):
     with pytest.raises(ValueError):
         diff_processor.get_context_of_line(
             path='file.txt', diff_line=diffs.DiffLineNumber(old=7, new=7))
 
 
 def test_context_of_an_old_line_number(diff_processor):
     context = diff_processor.get_context_of_line(
         path='file.txt', diff_line=diffs.DiffLineNumber(old=7, new=None))
     expected_context = [
         ('unmod', 'line04\n'),
         ('unmod', 'line05\n'),
         ('unmod', 'line06\n'),
         ('unmod', 'line07\n'),
         ('add', 'line07a Add after line07\n'),
         ('unmod', 'line08\n'),
         ('unmod', 'line09\n'),
     ]
     assert context == expected_context
 
 
 def test_context_of_a_new_line_number(diff_processor):
     context = diff_processor.get_context_of_line(
         path='file.txt', diff_line=diffs.DiffLineNumber(old=None, new=8))
     expected_context = [
         ('unmod', 'line05\n'),
         ('unmod', 'line06\n'),
         ('unmod', 'line07\n'),
         ('add', 'line07a Add after line07\n'),
         ('unmod', 'line08\n'),
         ('unmod', 'line09\n'),
         ('unmod', 'line10\n'),
     ]
     assert context == expected_context
 
 
 def test_context_of_an_invisible_line_beginning_of_hunk(diff_processor):
     # Note: The caller has to pass in a diff which is suitable to satisfy
     # its requirements. This test just ensures that we see a sane behavior.
     context = diff_processor.get_context_of_line(
         path='file.txt', diff_line=diffs.DiffLineNumber(old=None, new=3))
     expected_context = [
         ('unmod', 'line02\n'),
         ('unmod', 'line03\n'),
         ('unmod', 'line04\n'),
         ('unmod', 'line05\n'),
         ('unmod', 'line06\n'),
     ]
     assert context == expected_context
 
 
 def test_context_of_an_invisible_line_end_of_hunk(diff_processor):
     # Note: The caller has to pass in a diff which is suitable to satisfy
     # its requirements. This test just ensures that we see a sane behavior.
     context = diff_processor.get_context_of_line(
         path='file.txt', diff_line=diffs.DiffLineNumber(old=12, new=None))
     expected_context = [
         ('unmod', 'line09\n'),
         ('unmod', 'line10\n'),
         ('unmod', 'line11\n'),
         ('unmod', 'line12\n'),
         ('unmod', 'line13\n'),
     ]
     assert context == expected_context
 
 
 @pytest.mark.parametrize('diff_fixture', ['change-in-beginning.diff'])
 def test_context_of_an_incomplete_hunk_in_the_beginning(diff_processor):
     context = diff_processor.get_context_of_line(
         path='file.txt', diff_line=diffs.DiffLineNumber(old=None, new=2))
     expected_context = [
         ('unmod', 'line01\n'),
         ('add', 'line01a Add line after line01\n'),
         ('unmod', 'line02\n'),
         ('unmod', 'line03\n'),
         ('unmod', 'line04\n'),
     ]
     assert context == expected_context
 
 
 @pytest.mark.parametrize('diff_fixture', ['change-in-end.diff'])
 def test_context_of_an_incomplete_hunk_in_the_end(diff_processor):
     context = diff_processor.get_context_of_line(
         path='file.txt', diff_line=diffs.DiffLineNumber(old=None, new=80))
     expected_context = [
         ('unmod', 'line36\n'),
         ('unmod', 'line37\n'),
         ('unmod', 'line38\n'),
         ('add', 'line38a Add line after line38\n'),
         ('unmod', 'line39\n'),
     ]
     assert context == expected_context
 
 
 @pytest.mark.parametrize('diff_fixture', [
     'single-line.diff',
     'single-line-two-files.diff',
 ])
 def test_appends_newline_for_each_context_line(diff_processor):
     context = diff_processor.get_context_of_line(
         path='file_b', diff_line=diffs.DiffLineNumber(old=None, new=1))
     assert context == [('add', 'test_content\n')]
 
 
 def test_context_of_a_missing_line_raises(diff_processor):
     missing_line = 20
     with pytest.raises(diffs.LineNotInDiffException):
         diff_processor.get_context_of_line(
             path='file.txt',
             diff_line=diffs.DiffLineNumber(old=None, new=missing_line))
 
 
 def test_context_of_a_missing_file_raises(diff_processor):
     with pytest.raises(diffs.FileNotInDiffException):
         diff_processor.get_context_of_line(
             path='not_existing_file.txt',
             diff_line=diffs.DiffLineNumber(old=None, new=8))
 
 
 def test_find_context_with_full_context(diff_processor):
     context_of_line_7 = [
         ('unmod', 'line05\n'),
         ('unmod', 'line06\n'),
         ('unmod', 'line07\n'),
         ('add', 'line07a Add after line07\n'),
         ('unmod', 'line08\n'),
         ('unmod', 'line09\n'),
         ('unmod', 'line10\n'),
     ]
     found_line = diff_processor.find_context(
         'file.txt', context_of_line_7, offset=3)
     assert found_line == [diffs.DiffLineNumber(old=None, new=8)]
 
 
 @pytest.mark.parametrize('diff_fixture', ['change-duplicated.diff'])
 def test_find_context_multiple_times(diff_processor):
     context = [
         ('unmod', 'line04\n'),
         ('unmod', 'line05\n'),
         ('unmod', 'line06\n'),
         ('add', 'line06a add line\n'),
         ('unmod', 'line07\n'),
         ('unmod', 'line08\n'),
         ('unmod', 'line09\n'),
     ]
     found_line = diff_processor.find_context('file.txt', context, offset=3)
     assert found_line == [
         diffs.DiffLineNumber(old=None, new=7),
         diffs.DiffLineNumber(old=None, new=49),
     ]
 
 
 @pytest.mark.parametrize('offset', [20, -20, -1, 7])
 def test_find_context_offset_param_raises(diff_processor, offset):
     context_of_line_7 = [
         ('unmod', 'line04\n'),
         ('unmod', 'line05\n'),
         ('unmod', 'line06\n'),
         ('unmod', 'line07\n'),
         ('add', 'line07a Add after line07\n'),
         ('unmod', 'line08\n'),
         ('unmod', 'line09\n'),
     ]
     with pytest.raises(ValueError):
         diff_processor.find_context(
             'file.txt', context_of_line_7, offset=offset)
 
 
 def test_find_context_beginning_of_chunk(diff_processor):
     context_of_first_line = [
         ('unmod', 'line02\n'),
         ('unmod', 'line03\n'),
         ('unmod', 'line04\n'),
         ('unmod', 'line05\n'),
     ]
     found_line = diff_processor.find_context(
         'file.txt', context_of_first_line, offset=0)
     assert found_line == [diffs.DiffLineNumber(old=2, new=2)]
 
 
 @pytest.mark.parametrize('diff_fixture', ['change-in-beginning.diff'])
 def test_find_context_beginning_of_file(diff_processor):
     context_of_first_line = [
         ('add', 'line01a Add line after line01\n'),
         ('unmod', 'line02\n'),
         ('unmod', 'line03\n'),
         ('unmod', 'line04\n'),
         ('unmod', 'line05\n'),
         ('unmod', 'line06\n'),
         ('unmod', 'line07\n'),
     ]
     found_line = diff_processor.find_context(
         'file.txt', context_of_first_line, offset=3)
     assert found_line == [diffs.DiffLineNumber(old=4, new=5)]
 
 
 def test_find_context_end_of_chunk(diff_processor):
     context_of_last_line = [
         ('unmod', 'line10\n'),
         ('unmod', 'line11\n'),
         ('unmod', 'line12\n'),
         ('unmod', 'line13\n'),
     ]
     found_line = diff_processor.find_context(
         'file.txt', context_of_last_line, offset=3)
     assert found_line == [diffs.DiffLineNumber(old=13, new=14)]
 
 
[e-mail]
[e-mail]()
 def diff_processor(request, diff_fixture):
     raw_diff = diffs_store[diff_fixture]
     diff = GitDiff(raw_diff)
     processor = diffs.DiffProcessor(diff)
     processor.prepare()
     return processor
 
 
[e-mail]
[e-mail]()
 def diff_fixture():
     return 'default.diff'
 
 
 diff_default = textwrap.dedent("""
     diff --git a/file.txt b/file.txt
     index 76e4f2e..6f8738f 100644
     --- a/file.txt
     +++ b/file.txt
     @@ -2,12 +2,13 @@ line01
      line02
      line03
      line04
      line05
      line06
      line07
     +line07a Add after line07
      line08
      line09
      line10
      line11
      line12
      line13
 """)
 
 
 diff_beginning = textwrap.dedent("""
     diff --git a/file.txt b/file.txt
     index 76e4f2e..47d39f4 100644
     --- a/file.txt
     +++ b/file.txt
     @@ -1,7 +1,8 @@
      line01
     +line01a Add line after line01
      line02
      line03
      line04
      line05
      line06
      line07
 """)
 
 
 diff_end = textwrap.dedent("""
     diff --git a/file.txt b/file.txt
     index 76e4f2e..b1304db 100644
     --- a/file.txt
     +++ b/file.txt
     @@ -74,7 +74,8 @@ line32
      line33
      line34
      line35
      line36
      line37
      line38
     +line38a Add line after line38
      line39
 """)
 
 
 diff_duplicated_change = textwrap.dedent("""
     diff --git a/file.txt b/file.txt
     index 76e4f2e..55c2781 100644
     --- a/file.txt
     +++ b/file.txt
     @@ -1,12 +1,13 @@
      line01
      line02
      line03
      line04
      line05
      line06
     +line06a add line
      line07
      line08
      line09
      line10
      line11
      line12
     @@ -42,12 +43,13 @@ line39
      line01
      line02
      line03
      line04
      line05
      line06
     +line06a add line
      line07
      line08
      line09
      line10
      line11
      line12
 """)
 
 
 diff_single_line = textwrap.dedent("""
     diff --git a/file_b b/file_b
     new file mode 100644
     index 00000000..915e94ff
     --- /dev/null
     +++ b/file_b
     @@ -0,0 +1 @@
     +test_content
 """)
 
 
 diff_single_line_two_files = textwrap.dedent("""
     diff --git a/file_b b/file_b
     new file mode 100644
     index 00000000..915e94ff
     --- /dev/null
     +++ b/file_b
     @@ -0,0 +1 @@
     +test_content
     diff --git a/file_c b/file_c
     new file mode 100644
     index 00000000..915e94ff
     --- /dev/null
     +++ b/file_c
     @@ -0,0 +1 @@
     +test_content
 """)
 
 
 diffs_store = {
     'default.diff': diff_default,
     'change-in-beginning.diff': diff_beginning,
     'change-in-end.diff': diff_end,
     'change-duplicated.diff': diff_duplicated_change,
     'single-line.diff': diff_single_line,
     'single-line-two-files.diff': diff_single_line_two_files,
 }

rhodecode/tests/lib/test_hooks_base.py

@@ -1,151 +1,151 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 from rhodecode.model.db import Session, UserLog
 from rhodecode.lib import hooks_base, utils2
 
 
 def test_post_push_truncates_commits(user_regular, repo_stub):
     extras = {
         'ip': '127.0.0.1',
         'username': user_regular.username,
         'user_id': user_regular.user_id,
         'action': 'push_local',
         'repository': repo_stub.repo_name,
         'scm': 'git',
         'config': '',
         'server_url': 'http://example.com',
         'make_lock': None,
         'user_agent': 'some-client',
         'locked_by': [None],
         'commit_ids': ['abcde12345' * 4] * 30000,
         'hook_type': 'large_push_test_type',
         'is_shadow_repo': False,
     }
     extras = utils2.AttributeDict(extras)
 
     hooks_base.post_push(extras)
 
     # Calculate appropriate action string here
     commit_ids = extras.commit_ids[:400]
 
     entry = UserLog.query().order_by('-user_log_id').first()
     assert entry.action == 'user.push'
     assert entry.action_data['commit_ids'] == commit_ids
     Session().delete(entry)
     Session().commit()
 
 
 def assert_called_with_mock(callable_, expected_mock_name):
     mock_obj = callable_.call_args[0][0]
     mock_name = mock_obj._mock_new_parent._mock_new_name
     assert mock_name == expected_mock_name
 
 
[e-mail]
[e-mail]()
 def hook_extras(user_regular, repo_stub):
     extras = utils2.AttributeDict({
         'ip': '127.0.0.1',
         'username': user_regular.username,
         'user_id': user_regular.user_id,
         'action': 'push',
         'repository': repo_stub.repo_name,
         'scm': '',
         'config': '',
         'repo_store': '',
         'server_url': 'http://example.com',
         'make_lock': None,
         'user_agent': 'some-client',
         'locked_by': [None],
         'commit_ids': [],
         'hook_type': 'test_type',
         'is_shadow_repo': False,
     })
     return extras
 
 
 @pytest.mark.parametrize('func, extension, event', [
     (hooks_base.pre_push, 'pre_push_extension', 'RepoPrePushEvent'),
     (hooks_base.post_push, 'post_pull_extension', 'RepoPushEvent'),
     (hooks_base.pre_pull, 'pre_pull_extension', 'RepoPrePullEvent'),
     (hooks_base.post_pull, 'post_push_extension', 'RepoPullEvent'),
 ])
 def test_hooks_propagate(func, extension, event, hook_extras):
     """
     Tests that our hook code propagates to rhodecode extensions and triggers
     the appropriate event.
     """
     class ExtensionMock(mock.Mock):
         @property
         def output(self):
             return 'MOCK'
 
     extension_mock = ExtensionMock()
     events_mock = mock.Mock()
     patches = {
         'Repository': mock.Mock(),
         'events': events_mock,
         extension: extension_mock,
     }
 
     # Clear shadow repo flag.
     hook_extras.is_shadow_repo = False
 
     # Execute hook function.
     with mock.patch.multiple(hooks_base, **patches):
         func(hook_extras)
 
     # Assert that extensions are called and event was fired.
     extension_mock.called_once()
     assert_called_with_mock(events_mock.trigger, event)
 
 
 @pytest.mark.parametrize('func, extension, event', [
     (hooks_base.pre_push, 'pre_push_extension', 'RepoPrePushEvent'),
     (hooks_base.post_push, 'post_pull_extension', 'RepoPushEvent'),
     (hooks_base.pre_pull, 'pre_pull_extension', 'RepoPrePullEvent'),
     (hooks_base.post_pull, 'post_push_extension', 'RepoPullEvent'),
 ])
 def test_hooks_propagates_not_on_shadow(func, extension, event, hook_extras):
     """
     If hooks are called by a request to a shadow repo we only want to run our
     internal hooks code but not external ones like rhodecode extensions or
     trigger an event.
     """
     extension_mock = mock.Mock()
     events_mock = mock.Mock()
     patches = {
         'Repository': mock.Mock(),
         'events': events_mock,
         extension: extension_mock,
     }
 
     # Set shadow repo flag.
     hook_extras.is_shadow_repo = True
 
     # Execute hook function.
     with mock.patch.multiple(hooks_base, **patches):
         func(hook_extras)
 
     # Assert that extensions are *not* called and event was *not* fired.
     assert not extension_mock.called
     assert not events_mock.trigger.called

rhodecode/tests/lib/test_hooks_daemon.py

@@ -1,332 +1,332 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import json
 import logging
 from StringIO import StringIO
 
 import mock
 import pytest
 
 from rhodecode.lib import hooks_daemon
 from rhodecode.tests.utils import assert_message_in_log
 
 
 class TestDummyHooksCallbackDaemon(object):
     def test_hooks_module_path_set_properly(self):
         daemon = hooks_daemon.DummyHooksCallbackDaemon()
         assert daemon.hooks_module == 'rhodecode.lib.hooks_daemon'
 
     def test_logs_entering_the_hook(self):
         daemon = hooks_daemon.DummyHooksCallbackDaemon()
         with mock.patch.object(hooks_daemon.log, 'debug') as log_mock:
             with daemon as return_value:
                 log_mock.assert_called_once_with(
                     'Running `%s` callback daemon', 'DummyHooksCallbackDaemon')
         assert return_value == daemon
 
     def test_logs_exiting_the_hook(self):
         daemon = hooks_daemon.DummyHooksCallbackDaemon()
         with mock.patch.object(hooks_daemon.log, 'debug') as log_mock:
             with daemon:
                 pass
         log_mock.assert_called_with(
             'Exiting `%s` callback daemon', 'DummyHooksCallbackDaemon')
 
 
 class TestHooks(object):
     def test_hooks_can_be_used_as_a_context_processor(self):
         hooks = hooks_daemon.Hooks()
         with hooks as return_value:
             pass
         assert hooks == return_value
 
 
 class TestHooksHttpHandler(object):
     def test_read_request_parses_method_name_and_arguments(self):
         data = {
             'method': 'test',
             'extras': {
                 'param1': 1,
                 'param2': 'a'
             }
         }
         request = self._generate_post_request(data)
         hooks_patcher = mock.patch.object(
             hooks_daemon.Hooks, data['method'], create=True, return_value=1)
 
         with hooks_patcher as hooks_mock:
             MockServer(hooks_daemon.HooksHttpHandler, request)
 
         hooks_mock.assert_called_once_with(data['extras'])
 
     def test_hooks_serialized_result_is_returned(self):
         request = self._generate_post_request({})
         rpc_method = 'test'
         hook_result = {
             'first': 'one',
             'second': 2
         }
         read_patcher = mock.patch.object(
             hooks_daemon.HooksHttpHandler, '_read_request',
             return_value=(rpc_method, {}))
         hooks_patcher = mock.patch.object(
             hooks_daemon.Hooks, rpc_method, create=True,
             return_value=hook_result)
 
         with read_patcher, hooks_patcher:
             server = MockServer(hooks_daemon.HooksHttpHandler, request)
 
         expected_result = json.dumps(hook_result)
         assert server.request.output_stream.buflist[-1] == expected_result
 
     def test_exception_is_returned_in_response(self):
         request = self._generate_post_request({})
         rpc_method = 'test'
         read_patcher = mock.patch.object(
             hooks_daemon.HooksHttpHandler, '_read_request',
             return_value=(rpc_method, {}))
         hooks_patcher = mock.patch.object(
             hooks_daemon.Hooks, rpc_method, create=True,
             side_effect=Exception('Test exception'))
 
         with read_patcher, hooks_patcher:
             server = MockServer(hooks_daemon.HooksHttpHandler, request)
 
         org_exc = json.loads(server.request.output_stream.buflist[-1])
         expected_result = {
             'exception': 'Exception',
             'exception_traceback': org_exc['exception_traceback'],
             'exception_args': ['Test exception']
         }
         assert org_exc == expected_result
 
     def test_log_message_writes_to_debug_log(self, caplog):
         ip_port = ('0.0.0.0', 8888)
         handler = hooks_daemon.HooksHttpHandler(
             MockRequest('POST /'), ip_port, mock.Mock())
         fake_date = '1/Nov/2015 00:00:00'
         date_patcher = mock.patch.object(
             handler, 'log_date_time_string', return_value=fake_date)
         with date_patcher, caplog.at_level(logging.DEBUG):
             handler.log_message('Some message %d, %s', 123, 'string')
 
         expected_message = '{} - - [{}] Some message 123, string'.format(
             ip_port[0], fake_date)
         assert_message_in_log(
             caplog.records, expected_message,
             levelno=logging.DEBUG, module='hooks_daemon')
 
     def _generate_post_request(self, data):
         payload = json.dumps(data)
         return 'POST / HTTP/1.0\nContent-Length: {}\n\n{}'.format(
             len(payload), payload)
 
 
 class ThreadedHookCallbackDaemon(object):
     def test_constructor_calls_prepare(self):
         prepare_daemon_patcher = mock.patch.object(
             hooks_daemon.ThreadedHookCallbackDaemon, '_prepare')
         with prepare_daemon_patcher as prepare_daemon_mock:
             hooks_daemon.ThreadedHookCallbackDaemon()
         prepare_daemon_mock.assert_called_once_with()
 
     def test_run_is_called_on_context_start(self):
         patchers = mock.patch.multiple(
             hooks_daemon.ThreadedHookCallbackDaemon,
             _run=mock.DEFAULT, _prepare=mock.DEFAULT, __exit__=mock.DEFAULT)
 
         with patchers as mocks:
             daemon = hooks_daemon.ThreadedHookCallbackDaemon()
             with daemon as daemon_context:
                 pass
             mocks['_run'].assert_called_once_with()
         assert daemon_context == daemon
 
     def test_stop_is_called_on_context_exit(self):
         patchers = mock.patch.multiple(
             hooks_daemon.ThreadedHookCallbackDaemon,
             _run=mock.DEFAULT, _prepare=mock.DEFAULT, _stop=mock.DEFAULT)
 
         with patchers as mocks:
             daemon = hooks_daemon.ThreadedHookCallbackDaemon()
             with daemon as daemon_context:
                 assert mocks['_stop'].call_count == 0
 
             mocks['_stop'].assert_called_once_with()
         assert daemon_context == daemon
 
 
 class TestHttpHooksCallbackDaemon(object):
     def test_prepare_inits_daemon_variable(self, tcp_server, caplog):
         with self._tcp_patcher(tcp_server), caplog.at_level(logging.DEBUG):
             daemon = hooks_daemon.HttpHooksCallbackDaemon()
         assert daemon._daemon == tcp_server
 
         _, port = tcp_server.server_address
         expected_uri = '{}:{}'.format('127.0.0.1', port)
         msg = 'Preparing HTTP callback daemon at `{}` and ' \
               'registering hook object'.format(expected_uri)
         assert_message_in_log(
             caplog.records, msg, levelno=logging.DEBUG, module='hooks_daemon')
 
     def test_prepare_inits_hooks_uri_and_logs_it(
             self, tcp_server, caplog):
         with self._tcp_patcher(tcp_server), caplog.at_level(logging.DEBUG):
             daemon = hooks_daemon.HttpHooksCallbackDaemon()
 
         _, port = tcp_server.server_address
         expected_uri = '{}:{}'.format('127.0.0.1', port)
         assert daemon.hooks_uri == expected_uri
 
         msg = 'Preparing HTTP callback daemon at `{}` and ' \
               'registering hook object'.format(expected_uri)
         assert_message_in_log(
             caplog.records, msg,
             levelno=logging.DEBUG, module='hooks_daemon')
 
     def test_run_creates_a_thread(self, tcp_server):
         thread = mock.Mock()
 
         with self._tcp_patcher(tcp_server):
             daemon = hooks_daemon.HttpHooksCallbackDaemon()
 
         with self._thread_patcher(thread) as thread_mock:
             daemon._run()
 
         thread_mock.assert_called_once_with(
             target=tcp_server.serve_forever,
             kwargs={'poll_interval': daemon.POLL_INTERVAL})
         assert thread.daemon is True
         thread.start.assert_called_once_with()
 
     def test_run_logs(self, tcp_server, caplog):
 
         with self._tcp_patcher(tcp_server):
             daemon = hooks_daemon.HttpHooksCallbackDaemon()
 
         with self._thread_patcher(mock.Mock()), caplog.at_level(logging.DEBUG):
             daemon._run()
 
         assert_message_in_log(
             caplog.records,
             'Running event loop of callback daemon in background thread',
             levelno=logging.DEBUG, module='hooks_daemon')
 
     def test_stop_cleans_up_the_connection(self, tcp_server, caplog):
         thread = mock.Mock()
 
         with self._tcp_patcher(tcp_server):
             daemon = hooks_daemon.HttpHooksCallbackDaemon()
 
         with self._thread_patcher(thread), caplog.at_level(logging.DEBUG):
             with daemon:
                 assert daemon._daemon == tcp_server
                 assert daemon._callback_thread == thread
 
         assert daemon._daemon is None
         assert daemon._callback_thread is None
         tcp_server.shutdown.assert_called_with()
         thread.join.assert_called_once_with()
 
         assert_message_in_log(
             caplog.records, 'Waiting for background thread to finish.',
             levelno=logging.DEBUG, module='hooks_daemon')
 
     def _tcp_patcher(self, tcp_server):
         return mock.patch.object(
             hooks_daemon, 'TCPServer', return_value=tcp_server)
 
     def _thread_patcher(self, thread):
         return mock.patch.object(
             hooks_daemon.threading, 'Thread', return_value=thread)
 
 
 class TestPrepareHooksDaemon(object):
     @pytest.mark.parametrize('protocol', ('http',))
     def test_returns_dummy_hooks_callback_daemon_when_using_direct_calls(
             self, protocol):
         expected_extras = {'extra1': 'value1'}
         callback, extras = hooks_daemon.prepare_callback_daemon(
             expected_extras.copy(), protocol=protocol,
             host='127.0.0.1', use_direct_calls=True)
         assert isinstance(callback, hooks_daemon.DummyHooksCallbackDaemon)
         expected_extras['hooks_module'] = 'rhodecode.lib.hooks_daemon'
         expected_extras['time'] = extras['time']
         assert 'extra1' in extras
 
     @pytest.mark.parametrize('protocol, expected_class', (
         ('http', hooks_daemon.HttpHooksCallbackDaemon),
     ))
     def test_returns_real_hooks_callback_daemon_when_protocol_is_specified(
             self, protocol, expected_class):
         expected_extras = {
             'extra1': 'value1',
             'txn_id': 'txnid2',
             'hooks_protocol': protocol.lower()
         }
         callback, extras = hooks_daemon.prepare_callback_daemon(
             expected_extras.copy(), protocol=protocol, host='127.0.0.1',
             use_direct_calls=False,
             txn_id='txnid2')
         assert isinstance(callback, expected_class)
         extras.pop('hooks_uri')
         expected_extras['time'] = extras['time']
         assert extras == expected_extras
 
     @pytest.mark.parametrize('protocol', (
         'invalid',
         'Http',
         'HTTP',
     ))
     def test_raises_on_invalid_protocol(self, protocol):
         expected_extras = {
             'extra1': 'value1',
             'hooks_protocol': protocol.lower()
         }
         with pytest.raises(Exception):
             callback, extras = hooks_daemon.prepare_callback_daemon(
                 expected_extras.copy(),
                 protocol=protocol, host='127.0.0.1',
                 use_direct_calls=False)
 
 
 class MockRequest(object):
     def __init__(self, request):
         self.request = request
         self.input_stream = StringIO(b'{}'.format(self.request))
         self.output_stream = StringIO()
 
     def makefile(self, mode, *args, **kwargs):
         return self.output_stream if mode == 'wb' else self.input_stream
 
 
 class MockServer(object):
     def __init__(self, Handler, request):
         ip_port = ('0.0.0.0', 8888)
         self.request = MockRequest(request)
         self.handler = Handler(self.request, ip_port, self)
 
 
[e-mail]
[e-mail]()
 def tcp_server():
     server = mock.Mock()
     server.server_address = ('127.0.0.1', 8881)
     return server

rhodecode/tests/lib/test_jsonalchemy.py

@@ -1,107 +1,107 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pickle
 import pytest
 
 from sqlalchemy import Column, String, create_engine
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy.ext.declarative import declarative_base
 
 from rhodecode.lib.jsonalchemy import (
     MutationDict, MutationList, MutationObj, JsonType)
 
 
[e-mail]
[e-mail]()
 def engine():
     return create_engine('sqlite://')
 
 
[e-mail]
[e-mail]()
 def session(engine):
     return sessionmaker(bind=engine)()
 
 
 def test_mutation_dict_is_picklable():
     mutation_dict = MutationDict({'key1': 'value1', 'key2': 'value2'})
     dumped = pickle.dumps(mutation_dict)
     loaded = pickle.loads(dumped)
     assert loaded == mutation_dict
 
 
 def test_mutation_list_is_picklable():
     mutation_list = MutationList(['a', 'b', 'c'])
     dumped = pickle.dumps(mutation_list)
     loaded = pickle.loads(dumped)
     assert loaded == mutation_list
 
 
 def test_mutation_dict_with_lists_is_picklable():
     mutation_dict = MutationDict({
         'key': MutationList(['values', MutationDict({'key': 'value'})])
     })
     dumped = pickle.dumps(mutation_dict)
     loaded = pickle.loads(dumped)
     assert loaded == mutation_dict
 
 
 def test_mutation_types_with_nullable(engine, session):
     # TODO: dan: ideally want to make this parametrized python => sql tests eg:
     # (MutationObj, 5) => '5'
     # (MutationObj, {'a': 5}) => '{"a": 5}'
     # (MutationObj, None) => 'null' <- think about if None is 'null' or NULL
 
     Base = declarative_base()
 
     class DummyModel(Base):
         __tablename__ = 'some_table'
         name = Column(String, primary_key=True)
         json_list = Column(MutationList.as_mutable(JsonType('list')))
         json_dict = Column(MutationDict.as_mutable(JsonType('dict')))
         json_obj = Column(MutationObj.as_mutable(JsonType()))
 
     Base.metadata.create_all(engine)
 
     obj_nulls = DummyModel(name='nulls')
     obj_stuff = DummyModel(
         name='stuff', json_list=[1,2,3], json_dict={'a': 5}, json_obj=9)
 
     session.add(obj_nulls)
     session.add(obj_stuff)
     session.commit()
     session.expire_all()
 
     assert engine.execute(
         "select * from some_table where name = 'nulls';").first() == (
         (u'nulls', None, None, None)
     )
     ret_nulls = session.query(DummyModel).get('nulls')
     assert ret_nulls.json_list == []
     assert ret_nulls.json_dict == {}
     assert ret_nulls.json_obj is None
 
     assert engine.execute(
         "select * from some_table where name = 'stuff';").first() == (
         (u'stuff', u'[1, 2, 3]', u'{"a": 5}', u'9')
     )
     ret_stuff = session.query(DummyModel).get('stuff')
     assert ret_stuff.json_list == [1, 2, 3]
     assert ret_stuff.json_dict == {'a': 5}
     assert ret_stuff.json_obj == 9

rhodecode/tests/models/settings/test_settings.py

@@ -1,807 +1,807 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 from rhodecode.lib.utils2 import safe_str
 from rhodecode.model.db import (
     RhodeCodeUi, RepoRhodeCodeUi, RhodeCodeSetting, RepoRhodeCodeSetting)
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel, SettingNotFound, UiSetting
 
 
 class TestRepoGetUiByKey(object):
     def test_ui_settings_are_returned_when_key_is_found(
             self, repo_stub, settings_util):
         section = 'test section'
         value = 'test value'
 
         settings_util.create_repo_rhodecode_ui(
             repo_stub, 'wrong section', 'wrong value')
         setting = settings_util.create_repo_rhodecode_ui(
             repo_stub, section, value)
         key = setting.ui_key
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_ui_by_key(key)
         assert result.ui_value == value
         assert result.ui_section == section
         assert result.ui_active is True
 
     def test_none_is_returned_when_key_is_not_found(
             self, repo_stub, settings_util):
         settings_util.create_repo_rhodecode_ui(
             repo_stub, 'wrong section', 'wrong value')
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_ui_by_key('abcde')
         assert result is None
 
 
 class TestGlobalGetUiByKey(object):
     def test_ui_settings_are_returned_when_key_is_found(self, settings_util):
         section = 'test section'
         value = 'test value'
 
         settings_util.create_rhodecode_ui('wrong section', 'wrong value')
         setting = settings_util.create_rhodecode_ui(section, value)
         key = setting.ui_key
 
         model = SettingsModel()
         result = model.get_ui_by_key(key)
         assert result.ui_value == value
         assert result.ui_section == section
         assert result.ui_active is True
 
     def test_none_is_returned_when_key_is_not_found(self, settings_util):
         settings_util.create_rhodecode_ui('wrong section', 'wrong value')
         model = SettingsModel()
         result = model.get_ui_by_key('abcde')
         assert result is None
 
 
 class TestRepoGetUiBySection(object):
     def test_ui_settings_are_returned_when_section_is_found(
             self, repo_stub, settings_util):
         section = 'test section'
         values = ['test value 1', 'test value 2']
 
         expected_pairs = []
         for value in values:
             setting = settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, value)
             expected_pairs.append((setting.ui_key, value))
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_ui_by_section(section)
         result_pairs = [(r.ui_key, r.ui_value) for r in result]
         assert sorted(result_pairs) == sorted(expected_pairs)
 
     def test_empty_list_is_returned_when_section_is_not_found(
             self, repo_stub, settings_util):
         settings_util.create_repo_rhodecode_ui(
             repo_stub, 'wrong section', 'wrong value')
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_ui_by_section('correct section')
         assert result == []
 
 
 class TestGlobalGetUiBySection(object):
     def test_ui_settings_are_returned_when_section_is_found(
             self, settings_util):
         section = 'test section'
         values = ['test value 1', 'test value 2']
 
         expected_pairs = []
         for value in values:
             setting = settings_util.create_rhodecode_ui(section, value)
             expected_pairs.append((setting.ui_key, value))
 
         model = SettingsModel()
         result = model.get_ui_by_section(section)
         result_pairs = [(r.ui_key, r.ui_value) for r in result]
         assert sorted(result_pairs) == sorted(expected_pairs)
 
     def test_empty_list_is_returned_when_section_is_not_found(
             self, settings_util):
         settings_util.create_rhodecode_ui('wrong section', 'wrong value')
 
         model = SettingsModel()
         result = model.get_ui_by_section('correct section')
         assert result == []
 
 
 class TestRepoGetUiBySectionAndKey(object):
     def test_ui_settings_are_returned_when_section_and_key_are_found(
             self, repo_stub, settings_util):
         section = 'test section'
         value = 'test value'
         key = 'test key'
 
         settings_util.create_rhodecode_ui(
             'wrong section', 'wrong value', key='wrong key')
         setting = settings_util.create_repo_rhodecode_ui(
             repo_stub, section, value, key=key)
         key = setting.ui_key
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_ui_by_section_and_key(section, key)
         assert result.ui_value == value
         assert result.ui_section == section
         assert result.ui_active is True
 
     def test_none_is_returned_when_key_section_pair_is_not_found(
             self, repo_stub, settings_util):
         settings_util.create_repo_rhodecode_ui(
             repo_stub, 'section', 'wrong value', key='wrong key')
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_ui_by_section_and_key('section', 'test key')
         assert result is None
 
 
 class TestGlobalGetUiBySectionAndKey(object):
     def test_ui_settings_are_returned_when_section_and_key_are_found(
             self, settings_util):
         section = 'test section'
         value = 'test value'
         key = 'test key'
 
         settings_util.create_rhodecode_ui(
             'wrong section', 'wrong value', key='wrong key')
         setting = settings_util.create_rhodecode_ui(section, value, key=key)
         key = setting.ui_key
 
         model = SettingsModel()
         result = model.get_ui_by_section_and_key(section, key)
         assert result.ui_value == value
         assert result.ui_section == section
         assert result.ui_active is True
 
     def test_none_is_returned_when_key_section_pair_is_not_found(
             self, settings_util):
         settings_util.create_rhodecode_ui(
             'section', 'wrong value', key='wrong key')
         model = SettingsModel()
         result = model.get_ui_by_section_and_key('section', 'test key')
         assert result is None
 
 
 class TestRepoGetUi(object):
     def test_non_empty_list_is_returned_when_ui_settings_found(
             self, repo_stub, settings_util, fake_ui_values):
         for ui in fake_ui_values:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, ui.section, ui.value, key=ui.key)
             # Create few global settings to check that only repo ones are
             # displayed
             settings_util.create_rhodecode_ui(ui.section, ui.value, key=ui.key)
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_ui()
         assert sorted(result) == sorted(fake_ui_values)
 
     def test_settings_filtered_by_section(
             self, repo_stub, settings_util, fake_ui_values):
         for ui in fake_ui_values:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, ui.section, ui.value, key=ui.key)
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_ui(section=fake_ui_values[0].section)
         expected_result = [
             s for s in fake_ui_values
             if s.section == fake_ui_values[0].section]
         assert sorted(result) == sorted(expected_result)
 
     def test_settings_filtered_by_key(
             self, repo_stub, settings_util, fake_ui_values):
         for ui in fake_ui_values:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, ui.section, ui.value, key=ui.key)
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_ui(key=fake_ui_values[0].key)
         expected_result = [
             s for s in fake_ui_values if s.key == fake_ui_values[0].key]
         assert sorted(result) == sorted(expected_result)
 
     def test_empty_list_is_returned_when_ui_settings_are_not_found(
             self, repo_stub, settings_util):
         for i in range(10):
             settings_util.create_rhodecode_ui(
                 'section{}'.format(i), 'value{}'.format(i),
                 key='key{}'.format(i), active=True)
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_ui()
         assert result == []
 
 
 class TestGlobalGetUi(object):
     def test_non_empty_list_is_returned_when_ui_settings_found(
             self, backend_stub, settings_util, fake_ui_values):
         repo = backend_stub.create_repo()
         for ui in fake_ui_values:
             settings_util.create_rhodecode_ui(ui.section, ui.value, key=ui.key)
             # Create few repo settings to check that only global ones are
             # displayed
             settings_util.create_repo_rhodecode_ui(
                 repo, ui.section, ui.value, key=ui.key)
 
         model = SettingsModel()
         result = model.get_ui()
         for ui in fake_ui_values:
             assert ui in result
 
     def test_settings_filtered_by_key(self, settings_util, fake_ui_values):
         for ui in fake_ui_values:
             settings_util.create_rhodecode_ui(ui.section, ui.value, key=ui.key)
         expected_result = [
             s for s in fake_ui_values if s.key == fake_ui_values[0].key]
 
         model = SettingsModel()
         result = model.get_ui(key=fake_ui_values[0].key)
         assert sorted(result) == sorted(expected_result)
 
     def test_settings_filtered_by_section(self, settings_util, fake_ui_values):
         for ui in fake_ui_values:
             settings_util.create_rhodecode_ui(ui.section, ui.value, key=ui.key)
         expected_result = [
             s for s in fake_ui_values
             if s.section == fake_ui_values[0].section]
 
         model = SettingsModel()
         result = model.get_ui(section=fake_ui_values[0].section)
         assert sorted(result) == sorted(expected_result)
 
     def test_repo_settings_are_not_displayed(
             self, backend_stub, settings_util, fake_ui_values):
         repo = backend_stub.create_repo()
         for ui in fake_ui_values:
             settings_util.create_repo_rhodecode_ui(
                 repo, ui.section, ui.value, key=ui.key, active=ui.active)
 
         model = SettingsModel()
         result = model.get_ui()
         for ui in fake_ui_values:
             assert ui not in result
 
 
 class TestRepoGetBuiltInHooks(object):
     def test_only_builtin_hooks_are_returned(self, repo_stub, settings_util):
         section = 'hooks'
         valid_keys = SettingsModel.BUILTIN_HOOKS
         invalid_keys = ('fake_hook', )
         keys = valid_keys + invalid_keys
 
         for key in keys:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, 'test value', key=key)
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_builtin_hooks()
 
         assert len(result) == len(valid_keys)
         for entry in result:
             assert entry.ui_key in valid_keys
 
 
 class TestGlobalGetBuiltInHooks(object):
     def test_only_builtin_hooks_are_returned(self, settings_util):
         section = 'hooks'
         valid_keys = ('valid_key1', 'valid_key2')
         invalid_keys = ('fake_hook', )
         keys = valid_keys + invalid_keys
 
         for key in keys:
             settings_util.create_rhodecode_ui(section, 'test value', key=key)
 
         model = SettingsModel()
         with mock.patch.object(model, 'BUILTIN_HOOKS', valid_keys):
             result = model.get_builtin_hooks()
 
         assert len(result) == len(valid_keys)
         for entry in result:
             assert entry.ui_key in valid_keys
 
 
 class TestRepoGetCustomHooks(object):
     def test_only_custom_hooks_are_returned(self, repo_stub, settings_util):
         section = 'hooks'
         valid_keys = ('custom', )
         invalid_keys = SettingsModel.BUILTIN_HOOKS
         keys = valid_keys + invalid_keys
 
         for key in keys:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, 'test value', key=key)
 
         model = SettingsModel(repo=repo_stub.repo_name)
         result = model.get_custom_hooks()
 
         assert len(result) == len(valid_keys)
         for entry in result:
             assert entry.ui_key in valid_keys
 
 
 class TestGlobalGetCustomHooks(object):
     def test_only_custom_hooks_are_returned(self, settings_util):
         section = 'hooks'
         valid_keys = ('valid_key1', 'valid_key2')
         invalid_keys = ('fake_hook', )
         keys = valid_keys + invalid_keys
 
         for key in keys:
             settings_util.create_rhodecode_ui(section, 'test value', key=key)
 
         model = SettingsModel()
         with mock.patch.object(model, 'BUILTIN_HOOKS', invalid_keys):
             result = model.get_custom_hooks()
         for entry in result:
             assert entry.ui_key not in invalid_keys
 
 
 class TestRepoCreateUiSectionValue(object):
     @pytest.mark.parametrize("additional_kwargs", [
         {'key': 'abcde'},
         {'active': False},
         {}
     ])
     def test_ui_section_value_is_created(
             self, repo_stub, additional_kwargs):
         model = SettingsModel(repo=repo_stub.repo_name)
         section = 'test section'
         value = 'test value'
         result = model.create_ui_section_value(section, value)
         key = result.ui_key
         Session().commit()
 
         setting = model.get_ui_by_key(key)
         try:
             assert setting == result
             assert isinstance(setting, RepoRhodeCodeUi)
         finally:
             Session().delete(result)
             Session().commit()
 
 
 class TestGlobalCreateUiSectionValue(object):
     @pytest.mark.parametrize("additional_kwargs", [
         {'key': 'abcde'},
         {'active': False},
         {}
     ])
     def test_ui_section_value_is_created_with_autogenerated_key(
             self, backend_stub, additional_kwargs):
         model = SettingsModel()
         section = 'test section'
         value = 'test value'
         result = model.create_ui_section_value(
             section, value, **additional_kwargs)
         key = result.ui_key
         Session().commit()
 
         setting = model.get_ui_by_key(key)
         try:
             assert setting == result
             assert isinstance(setting, RhodeCodeUi)
         finally:
             Session().delete(result)
             Session().commit()
 
 
 class TestRepoCreateOrUpdateHook(object):
     def test_hook_created(self, repo_stub):
         model = SettingsModel(repo=repo_stub.repo_name)
         key = 'test_key'
         value = 'test value'
         result = model.create_or_update_hook(key, value)
         Session().commit()
 
         setting = model.get_ui_by_section_and_key('hooks', key)
         try:
             assert setting == result
             assert isinstance(setting, RepoRhodeCodeUi)
         finally:
             Session().delete(result)
             Session().commit()
 
     def test_hook_updated(self, repo_stub, settings_util):
         section = 'hooks'
         key = 'test_key'
 
         settings_util.create_repo_rhodecode_ui(
             repo_stub, section, 'old value', key=key)
 
         model = SettingsModel(repo=repo_stub.repo_name)
         value = 'test value'
         model.create_or_update_hook(key, value)
         Session().commit()
 
         setting = model.get_ui_by_section_and_key('hooks', key)
         assert setting.ui_value == value
 
 
 class TestGlobalCreateOrUpdateHook(object):
     def test_hook_created(self):
         model = SettingsModel()
         key = 'test_key'
         value = 'test value'
         result = model.create_or_update_hook(key, value)
         Session().commit()
 
         setting = model.get_ui_by_section_and_key('hooks', key)
         try:
             assert setting == result
             assert isinstance(setting, RhodeCodeUi)
         finally:
             Session().delete(result)
             Session().commit()
 
     def test_hook_updated(self, settings_util):
         section = 'hooks'
         key = 'test_key'
 
         settings_util.create_rhodecode_ui(section, 'old value', key=key)
 
         model = SettingsModel()
         value = 'test value'
         model.create_or_update_hook(key, value)
         Session().commit()
 
         setting = model.get_ui_by_section_and_key('hooks', key)
         assert setting.ui_value == value
 
 
 class TestDeleteUiValue(object):
     def test_delete_ui_when_repo_is_set(self, repo_stub, settings_util):
         model = SettingsModel(repo=repo_stub.repo_name)
         result = settings_util.create_repo_rhodecode_ui(
             repo_stub, 'section', None, cleanup=False)
 
         key = result.ui_key
         model.delete_ui(result.ui_id)
         Session().commit()
 
         setting = model.get_ui_by_key(key)
         assert setting is None
 
     @pytest.mark.parametrize('id_', (None, 123))
     def test_raises_exception_when_id_is_not_specified(self, id_):
         model = SettingsModel()
         with pytest.raises(SettingNotFound) as exc_info:
             model.delete_ui(id_)
         assert str(exc_info.value) == 'Setting `{}` is not found'.format(id_)
 
     def test_delete_ui_when_repo_is_not_set(self, settings_util):
         model = SettingsModel()
         result = settings_util.create_rhodecode_ui(
             'section', None, cleanup=False)
 
         key = result.ui_key
         model.delete_ui(result.ui_id)
         Session().commit()
 
         setting = model.get_ui_by_key(key)
         assert setting is None
 
 
 class TestRepoGetSettingByName(object):
     @pytest.mark.parametrize("name, value, type_, expected_value", [
         ('test_unicode', 'Straße', 'unicode', 'Straße'),
         ('test_int', '1234', 'int', 1234),
         ('test_bool', 'True', 'bool', True),
         ('test_list', 'a,b,c', 'list', ['a', 'b', 'c'])
     ])
     def test_setting_is_returned_when_name_is_found(
             self, repo_stub, settings_util, name, value, type_,
             expected_value):
         settings_util.create_repo_rhodecode_setting(
             repo_stub, name, value, type_)
 
         model = SettingsModel(repo=repo_stub.repo_name)
         setting = model.get_setting_by_name(name)
         assert setting.app_settings_type == type_
         actual_value = setting.app_settings_value
         if type_ == 'unicode':
             actual_value = safe_str(actual_value)
         assert actual_value == expected_value
 
     def test_returns_none_if_the_setting_does_not_exist(self, repo_stub):
         model = SettingsModel(repo=repo_stub.repo_name)
         setting = model.get_setting_by_name('abcde')
         assert setting is None
 
 
 class TestGlobalGetSettingByName(object):
     @pytest.mark.parametrize("name, value, type_, expected_value", [
         ('test_unicode', 'Straße', 'unicode', 'Straße'),
         ('test_int', '1234', 'int', 1234),
         ('test_bool', 'True', 'bool', True),
         ('test_list', 'a,b,c', 'list', ['a', 'b', 'c'])
     ])
     def test_setting_is_returned_when_name_is_found(
             self, settings_util, name, value, type_, expected_value):
         settings_util.create_rhodecode_setting(name, value, type_)
 
         model = SettingsModel()
         setting = model.get_setting_by_name(name)
         assert setting.app_settings_type == type_
         actual_value = setting.app_settings_value
         if type_ == 'unicode':
             actual_value = safe_str(actual_value)
         assert actual_value == expected_value
 
     def test_returns_none_if_the_setting_does_not_exist(self):
         model = SettingsModel()
         setting = model.get_setting_by_name('abcde')
         assert setting is None
 
 
 class TestRepoGetAllSettings(object):
     def test_settings_are_found(self, repo_stub, settings_util):
         initial_settings = {
             'test_setting_{}'.format(i): 'value' for i in range(10)}
         settings = [
             settings_util.create_repo_rhodecode_setting(
                 repo_stub, name, initial_settings[name], 'unicode')
             for name in initial_settings
         ]
         model = SettingsModel(repo=repo_stub.repo_name)
 
         settings = model.get_all_settings()
         expected_settings = {
             'rhodecode_' + name: initial_settings[name]
             for name in initial_settings
         }
 
         assert len(settings) == 10
         assert expected_settings == settings
 
     def test_settings_are_not_found(self, repo_stub):
         model = SettingsModel(repo=repo_stub.repo_name)
         setting = model.get_all_settings()
         assert setting == {}
 
 
 class TestGlobalGetAllSettings(object):
     def test_settings_are_found(self, settings_util):
         initial_settings = {
             'test_setting_{}'.format(i): 'value' for i in range(10)}
         settings = [
             settings_util.create_rhodecode_setting(
                 name, initial_settings[name], 'unicode')
             for name in initial_settings
         ]
         model = SettingsModel()
 
         settings = model.get_all_settings()
         expected_settings = {
             'rhodecode_' + name: initial_settings[name]
             for name in initial_settings
         }
 
         filtered_settings = {
             name: settings[name]
             for name in settings if name.startswith('rhodecode_test_setting')
         }
         assert len(filtered_settings) == 10
         assert expected_settings == filtered_settings
 
     def test_settings_are_not_found(self, repo_stub):
         model = SettingsModel(repo=repo_stub.repo_name)
         setting = model.get_all_settings()
         assert setting == {}
 
 
 class TestRepoCreateOrUpdateSetting(object):
     def test_setting_is_created(self, repo_stub):
         model = SettingsModel(repo=repo_stub.repo_name)
         name = 'test_setting'
         value = 'test_value'
         model.create_or_update_setting(name, val=value)
 
         setting = model.get_setting_by_name(name)
         try:
             assert setting.app_settings_name == name
             assert setting.app_settings_value == value
             assert setting.app_settings_type == 'unicode'
             assert isinstance(setting, RepoRhodeCodeSetting)
         finally:
             Session().delete(setting)
             Session().commit()
 
     def test_setting_is_updated(self, repo_stub, settings_util):
         model = SettingsModel(repo=repo_stub.repo_name)
         name = 'test_setting'
         value = 'test_value'
         settings_util.create_repo_rhodecode_setting(
             repo_stub, name, value, 'unicode', cleanup=False)
 
         updated_value = 'test_value_2'
         model.create_or_update_setting(name, val=updated_value)
 
         setting = model.get_setting_by_name(name)
         try:
             assert setting.app_settings_name == name
             assert setting.app_settings_value == updated_value
             assert setting.app_settings_type == 'unicode'
             assert isinstance(setting, RepoRhodeCodeSetting)
         finally:
             Session().delete(setting)
             Session().commit()
 
 
 class TestGlobalCreateOrUpdateSetting(object):
     def test_setting_is_created(self):
         model = SettingsModel()
         name = 'test_setting'
         value = 'test_value'
         model.create_or_update_setting(name, val=value)
 
         setting = model.get_setting_by_name(name)
         try:
             assert setting.app_settings_name == name
             assert setting.app_settings_value == value
             assert setting.app_settings_type == 'unicode'
             assert isinstance(setting, RhodeCodeSetting)
         finally:
             Session().delete(setting)
             Session().commit()
 
     def test_setting_is_updated(self, settings_util):
         model = SettingsModel()
         name = 'test_setting'
         value = 'test_value'
         settings_util.create_rhodecode_setting(
             name, value, 'unicode', cleanup=False)
 
         updated_value = 'test_value_2'
         model.create_or_update_setting(name, val=updated_value)
 
         setting = model.get_setting_by_name(name)
         try:
             assert setting.app_settings_name == name
             assert setting.app_settings_value == updated_value
             assert setting.app_settings_type == 'unicode'
             assert isinstance(setting, RhodeCodeSetting)
         finally:
             Session().delete(setting)
             Session().commit()
 
 
 class TestRepoGetAuthSettings(object):
     def test_settings_prefixed_with_auth_are_retured(
             self, repo_stub, settings_util):
         model = SettingsModel(repo=repo_stub.repo_name)
         valid_settings = ('auth_test1', 'auth_test2')
         invalid_settings = ('test1', 'test2')
         fake_value = 'test_value'
 
         for name in valid_settings + invalid_settings:
             settings_util.create_repo_rhodecode_setting(
                 repo_stub, name, fake_value, 'unicode')
 
         auth_settings = model.get_auth_settings()
         assert auth_settings == {name: fake_value for name in valid_settings}
 
 
 class TestGlobalGetAuthSettings(object):
     def test_settings_prefixed_with_auth_are_retured(self, settings_util):
         model = SettingsModel()
         valid_settings = ('auth_test1', 'auth_test2')
         invalid_settings = ('test1', 'test2')
         fake_value = 'test_value'
 
         for name in valid_settings + invalid_settings:
             settings_util.create_rhodecode_setting(name, fake_value, 'unicode')
 
         auth_settings = model.get_auth_settings()
         for name in auth_settings:
             assert name not in invalid_settings
             if name in valid_settings:
                 assert auth_settings[name] == fake_value
 
 
 class TestGetAuthPlugins(object):
     def test_get_setting_by_name_is_called(self):
         model = SettingsModel()
 
         fake_value = 'some value'
         result_mock = mock.Mock()
         result_mock.app_settings_value = fake_value
 
         get_setting_patch = mock.patch.object(
             model, 'get_setting_by_name', return_value=result_mock)
 
         with get_setting_patch as get_setting_mock:
             result = model.get_auth_plugins()
 
         get_setting_mock.assert_called_once_with('auth_plugins')
         assert result == fake_value
 
 
 class TestDefaultRepoSettings(object):
     DEFAULT_SETTINGS_NAMES = ['default_a{}'.format(i) for i in range(10)]
     CUSTOM_SETTINGS_NAMES = ['setting_b_{}'.format(i) for i in range(10)]
 
     def test_returns_global_settings_prefixed_with_default(
             self, settings_util):
         self._create_values(settings_util)
         model = SettingsModel()
         result = model.get_default_repo_settings()
         self._assert_prefixed_settings(result)
 
     def test_returns_global_settings_without_default_prefix(
             self, settings_util):
         self._create_values(settings_util)
         model = SettingsModel()
         result = model.get_default_repo_settings(strip_prefix=True)
         self._assert_non_prefixed_settings(result)
 
     def test_returns_per_repo_settings_prefixed_with_default(
             self, repo_stub, settings_util):
         model = SettingsModel(repo=repo_stub)
         self._create_values(settings_util, repo=repo_stub)
         result = model.get_default_repo_settings()
         self._assert_prefixed_settings(result)
 
     def test_returns_per_repo_settings_without_default_prefix(
             self, repo_stub, settings_util):
         model = SettingsModel(repo=repo_stub)
         self._create_values(settings_util, repo=repo_stub)
         result = model.get_default_repo_settings(strip_prefix=True)
         self._assert_non_prefixed_settings(result)
 
     def _create_values(self, settings_util, repo=None):
         for name in self.DEFAULT_SETTINGS_NAMES + self.CUSTOM_SETTINGS_NAMES:
             if not repo:
                 settings_util.create_rhodecode_setting(
                     name, 'value', 'unicode')
             else:
                 settings_util.create_repo_rhodecode_setting(
                     repo, name, 'value', 'unicode')
 
     def _assert_prefixed_settings(self, result):
         for setting in self.DEFAULT_SETTINGS_NAMES:
             assert setting in result
             assert result[setting] == 'value'
 
         for setting in self.CUSTOM_SETTINGS_NAMES:
             assert setting not in result
 
     def _assert_non_prefixed_settings(self, result):
         for setting in self.DEFAULT_SETTINGS_NAMES:
             setting = setting.replace('default_', '')
             assert setting in result
             assert result[setting] == 'value'
 
 
[e-mail]
[e-mail]()
 def fake_ui_values():
     return [
         UiSetting(
             'section{}'.format(i % 2), 'key{}'.format(i),
             'value{}'.format(i), True)
         for i in range(10)
     ]

rhodecode/tests/models/test_permissions.py

@@ -1,735 +1,735 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
 
 from rhodecode.lib.auth import AuthUser
 from rhodecode.model.db import (
     RepoGroup, User, UserGroupRepoGroupToPerm, Permission, UserToPerm,
     UserGroupToPerm)
 from rhodecode.model.meta import Session
 from rhodecode.model.permission import PermissionModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.tests.fixture import Fixture
 
 
 fixture = Fixture()
 
 
[e-mail]
[e-mail]()
 def repo_name(backend_hg):
     return backend_hg.repo_name
 
 
 class TestPermissions(object):
 
     @pytest.fixture(scope='class', autouse=True)
     def default_permissions(self, request, baseapp):
         # recreate default user to get a clean start
         PermissionModel().create_default_user_permissions(
             user=User.DEFAULT_USER, force=True)
         Session().commit()
 
     @pytest.fixture(autouse=True)
     def prepare_users(self, request):
         # TODO: User creation is a duplicate of test_nofitications, check
         # if that can be unified
         self.u1 = UserModel().create_or_update(
             username=u'u1', password=u'qweqwe',
             email=u'[e-mail]', firstname=u'u1', lastname=u'u1'
         )
         self.u2 = UserModel().create_or_update(
             username=u'u2', password=u'qweqwe',
             email=u'[e-mail]', firstname=u'u2', lastname=u'u2'
         )
         self.u3 = UserModel().create_or_update(
             username=u'u3', password=u'qweqwe',
             email=u'[e-mail]', firstname=u'u3', lastname=u'u3'
         )
         self.anon = User.get_default_user()
         self.a1 = UserModel().create_or_update(
             username=u'a1', password=u'qweqwe',
             email=u'[e-mail]', firstname=u'a1', lastname=u'a1',
             admin=True
         )
         Session().commit()
 
         request.addfinalizer(self.cleanup)
 
     def cleanup(self):
         if hasattr(self, 'test_repo'):
             RepoModel().delete(repo=self.test_repo)
 
         if hasattr(self, 'g1'):
             RepoGroupModel().delete(self.g1.group_id)
         if hasattr(self, 'g2'):
             RepoGroupModel().delete(self.g2.group_id)
 
         UserModel().delete(self.u1)
         UserModel().delete(self.u2)
         UserModel().delete(self.u3)
         UserModel().delete(self.a1)
 
         if hasattr(self, 'ug1'):
             UserGroupModel().delete(self.ug1, force=True)
 
         Session().commit()
 
     def test_default_perms_set(self, repo_name):
         assert repo_perms(self.u1)[repo_name] == 'repository.read'
         new_perm = 'repository.write'
         RepoModel().grant_user_permission(repo=repo_name, user=self.u1,
                                           perm=new_perm)
         Session().commit()
         assert repo_perms(self.u1)[repo_name] == new_perm
 
     def test_default_admin_perms_set(self, repo_name):
         assert repo_perms(self.a1)[repo_name] == 'repository.admin'
         RepoModel().grant_user_permission(repo=repo_name, user=self.a1,
                                           perm='repository.write')
         Session().commit()
         # cannot really downgrade admins permissions !? they still gets set as
         # admin !
         assert repo_perms(self.a1)[repo_name] == 'repository.admin'
 
     def test_default_group_perms(self, repo_name):
         self.g1 = fixture.create_repo_group('test1', skip_if_exists=True)
         self.g2 = fixture.create_repo_group('test2', skip_if_exists=True)
 
         assert repo_perms(self.u1)[repo_name] == 'repository.read'
         assert group_perms(self.u1) == {
             'test1': 'group.read', 'test2': 'group.read'}
         assert global_perms(self.u1) == set(
             Permission.DEFAULT_USER_PERMISSIONS)
 
     def test_default_admin_group_perms(self, repo_name):
         self.g1 = fixture.create_repo_group('test1', skip_if_exists=True)
         self.g2 = fixture.create_repo_group('test2', skip_if_exists=True)
 
         assert repo_perms(self.a1)[repo_name] == 'repository.admin'
         assert group_perms(self.a1) == {
             'test1': 'group.admin', 'test2': 'group.admin'}
 
     def test_default_owner_repo_perms(self, backend, user_util, test_repo):
         user = user_util.create_user()
         repo = test_repo('minimal', backend.alias)
         org_owner = repo.user
         assert repo_perms(user)[repo.repo_name] == 'repository.read'
 
         repo.user = user
         assert repo_perms(user)[repo.repo_name] == 'repository.admin'
         repo.user = org_owner
 
     def test_default_owner_branch_perms(self, user_util, test_user_group):
         user = user_util.create_user()
         assert branch_perms(user) == {}
 
     def test_default_owner_repo_group_perms(self, user_util, test_repo_group):
         user = user_util.create_user()
         org_owner = test_repo_group.user
 
         assert group_perms(user)[test_repo_group.group_name] == 'group.read'
 
         test_repo_group.user = user
         assert group_perms(user)[test_repo_group.group_name] == 'group.admin'
         test_repo_group.user = org_owner
 
     def test_default_owner_user_group_perms(self, user_util, test_user_group):
         user = user_util.create_user()
         org_owner = test_user_group.user
 
         assert user_group_perms(user)[test_user_group.users_group_name] == 'usergroup.read'
 
         test_user_group.user = user
         assert user_group_perms(user)[test_user_group.users_group_name] == 'usergroup.admin'
 
         test_user_group.user = org_owner
 
     def test_propagated_permission_from_users_group_by_explicit_perms_exist(
             self, repo_name):
         # make group
         self.ug1 = fixture.create_user_group('G1')
         UserGroupModel().add_user_to_group(self.ug1, self.u1)
 
         # set permission to lower
         new_perm = 'repository.none'
         RepoModel().grant_user_permission(
             repo=repo_name, user=self.u1, perm=new_perm)
         Session().commit()
         assert repo_perms(self.u1)[repo_name] == new_perm
 
         # grant perm for group this should not override permission from user
         # since it has explicitly set
         new_perm_gr = 'repository.write'
         RepoModel().grant_user_group_permission(
             repo=repo_name, group_name=self.ug1, perm=new_perm_gr)
 
         assert repo_perms(self.u1)[repo_name] == new_perm
         assert group_perms(self.u1) == {}
 
     def test_propagated_permission_from_users_group(self, repo_name):
         # make group
         self.ug1 = fixture.create_user_group('G1')
         UserGroupModel().add_user_to_group(self.ug1, self.u3)
 
         # grant perm for group
         # this should override default permission from user
         new_perm_gr = 'repository.write'
         RepoModel().grant_user_group_permission(
             repo=repo_name, group_name=self.ug1, perm=new_perm_gr)
 
         assert repo_perms(self.u3)[repo_name] == new_perm_gr
         assert group_perms(self.u3) == {}
 
     def test_propagated_permission_from_users_group_lower_weight(
             self, repo_name):
         # make group with user
         self.ug1 = fixture.create_user_group('G1')
         UserGroupModel().add_user_to_group(self.ug1, self.u1)
 
         # set permission to lower
         new_perm_h = 'repository.write'
         RepoModel().grant_user_permission(
             repo=repo_name, user=self.u1, perm=new_perm_h)
         Session().commit()
 
         assert repo_perms(self.u1)[repo_name] == new_perm_h
 
         # grant perm for group this should NOT override permission from user
         # since it's lower than granted
         new_perm_l = 'repository.read'
         RepoModel().grant_user_group_permission(
             repo=repo_name, group_name=self.ug1, perm=new_perm_l)
 
         assert repo_perms(self.u1)[repo_name] == new_perm_h
         assert group_perms(self.u1) == {}
 
     def test_repo_in_group_permissions(self):
         self.g1 = fixture.create_repo_group('group1', skip_if_exists=True)
         self.g2 = fixture.create_repo_group('group2', skip_if_exists=True)
         # both perms should be read !
         assert group_perms(self.u1) == \
             {u'group1': u'group.read', u'group2': u'group.read'}
 
         assert group_perms(self.anon) == \
             {u'group1': u'group.read', u'group2': u'group.read'}
 
         # Change perms to none for both groups
         RepoGroupModel().grant_user_permission(
             repo_group=self.g1, user=self.anon, perm='group.none')
         RepoGroupModel().grant_user_permission(
             repo_group=self.g2, user=self.anon, perm='group.none')
 
         assert group_perms(self.u1) == \
             {u'group1': u'group.none', u'group2': u'group.none'}
         assert group_perms(self.anon) == \
             {u'group1': u'group.none', u'group2': u'group.none'}
 
         # add repo to group
         name = RepoGroup.url_sep().join([self.g1.group_name, 'test_perm'])
         self.test_repo = fixture.create_repo(name=name,
                                              repo_type='hg',
                                              repo_group=self.g1,
                                              cur_user=self.u1,)
 
         assert group_perms(self.u1) == \
             {u'group1': u'group.none', u'group2': u'group.none'}
         assert group_perms(self.anon) == \
             {u'group1': u'group.none', u'group2': u'group.none'}
 
         # grant permission for u2 !
         RepoGroupModel().grant_user_permission(
             repo_group=self.g1, user=self.u2, perm='group.read')
         RepoGroupModel().grant_user_permission(
             repo_group=self.g2, user=self.u2, perm='group.read')
         Session().commit()
         assert self.u1 != self.u2
 
         # u1 and anon should have not change perms while u2 should !
         assert group_perms(self.u1) == \
             {u'group1': u'group.none', u'group2': u'group.none'}
         assert group_perms(self.u2) == \
             {u'group1': u'group.read', u'group2': u'group.read'}
         assert group_perms(self.anon) == \
             {u'group1': u'group.none', u'group2': u'group.none'}
 
     def test_repo_group_user_as_user_group_member(self):
         # create Group1
         self.g1 = fixture.create_repo_group('group1', skip_if_exists=True)
         assert group_perms(self.anon) == {u'group1': u'group.read'}
 
         # set default permission to none
         RepoGroupModel().grant_user_permission(
             repo_group=self.g1, user=self.anon, perm='group.none')
         # make group
         self.ug1 = fixture.create_user_group('G1')
         # add user to group
         UserGroupModel().add_user_to_group(self.ug1, self.u1)
         Session().commit()
 
         # check if user is in the group
         ug1 = UserGroupModel().get(self.ug1.users_group_id)
         members = [x.user_id for x in ug1.members]
         assert members == [self.u1.user_id]
         # add some user to that group
 
         # check his permissions
         assert group_perms(self.anon) == {u'group1': u'group.none'}
         assert group_perms(self.u1) == {u'group1': u'group.none'}
 
         # grant ug1 read permissions for
         RepoGroupModel().grant_user_group_permission(
             repo_group=self.g1, group_name=self.ug1, perm='group.read')
         Session().commit()
 
         # check if the
         obj = Session().query(UserGroupRepoGroupToPerm)\
             .filter(UserGroupRepoGroupToPerm.group == self.g1)\
             .filter(UserGroupRepoGroupToPerm.users_group == self.ug1)\
             .scalar()
         assert obj.permission.permission_name == 'group.read'
 
         assert group_perms(self.anon) == {u'group1': u'group.none'}
         assert group_perms(self.u1) == {u'group1': u'group.read'}
 
     def test_inherited_permissions_from_default_on_user_enabled(self):
         # enable fork and create on default user
         _form_result = {
             'default_repo_create': 'hg.create.repository',
             'default_fork_create': 'hg.fork.repository'
         }
         PermissionModel().set_new_user_perms(
             User.get_default_user(), _form_result)
         Session().commit()
 
         # make sure inherit flag is turned on
         self.u1.inherit_default_permissions = True
         Session().commit()
 
         # this user will have inherited permissions from default user
         assert global_perms(self.u1) == default_perms()
 
     def test_inherited_permissions_from_default_on_user_disabled(self):
         # disable fork and create on default user
         _form_result = {
             'default_repo_create': 'hg.create.none',
             'default_fork_create': 'hg.fork.none'
         }
         PermissionModel().set_new_user_perms(
             User.get_default_user(), _form_result)
         Session().commit()
 
         # make sure inherit flag is turned on
         self.u1.inherit_default_permissions = True
         Session().commit()
 
         # this user will have inherited permissions from default user
         expected_perms = default_perms(
             added=['hg.create.none', 'hg.fork.none'],
             removed=['hg.create.repository', 'hg.fork.repository'])
         assert global_perms(self.u1) == expected_perms
 
     def test_non_inherited_permissions_from_default_on_user_enabled(self):
         user_model = UserModel()
         # enable fork and create on default user
         usr = User.DEFAULT_USER
         user_model.revoke_perm(usr, 'hg.create.none')
         user_model.grant_perm(usr, 'hg.create.repository')
         user_model.revoke_perm(usr, 'hg.fork.none')
         user_model.grant_perm(usr, 'hg.fork.repository')
 
         # disable global perms on specific user
         user_model.revoke_perm(self.u1, 'hg.create.repository')
         user_model.grant_perm(self.u1, 'hg.create.none')
         user_model.revoke_perm(self.u1, 'hg.fork.repository')
         user_model.grant_perm(self.u1, 'hg.fork.none')
 
         # TODO(marcink): check branch permissions now ?
 
         # make sure inherit flag is turned off
         self.u1.inherit_default_permissions = False
         Session().commit()
 
         # this user will have non inherited permissions from he's
         # explicitly set permissions
         assert global_perms(self.u1) == {
             'hg.create.none',
             'hg.fork.none',
             'hg.register.manual_activate',
             'hg.password_reset.enabled',
             'hg.extern_activate.auto',
             'repository.read',
             'group.read',
             'usergroup.read',
             'branch.push_force',
         }
 
     def test_non_inherited_permissions_from_default_on_user_disabled(self):
         user_model = UserModel()
         # disable fork and create on default user
         usr = User.DEFAULT_USER
         user_model.revoke_perm(usr, 'hg.create.repository')
         user_model.grant_perm(usr, 'hg.create.none')
         user_model.revoke_perm(usr, 'hg.fork.repository')
         user_model.grant_perm(usr, 'hg.fork.none')
 
         # enable global perms on specific user
         user_model.revoke_perm(self.u1, 'hg.create.none')
         user_model.grant_perm(self.u1, 'hg.create.repository')
         user_model.revoke_perm(self.u1, 'hg.fork.none')
         user_model.grant_perm(self.u1, 'hg.fork.repository')
 
         # make sure inherit flag is turned off
         self.u1.inherit_default_permissions = False
         Session().commit()
 
         # TODO(marcink): check branch perms
 
         # this user will have non inherited permissions from he's
         # explicitly set permissions
         assert global_perms(self.u1) == {
             'hg.create.repository',
             'hg.fork.repository',
             'hg.register.manual_activate',
             'hg.password_reset.enabled',
             'hg.extern_activate.auto',
             'repository.read',
             'group.read',
             'usergroup.read',
             'branch.push_force',
         }
 
     @pytest.mark.parametrize('perm, expected_perm', [
         ('hg.inherit_default_perms.false', 'repository.none', ),
         ('hg.inherit_default_perms.true', 'repository.read', ),
     ])
     def test_inherited_permissions_on_objects(self, perm, expected_perm):
         _form_result = {
             'default_inherit_default_permissions': perm,
         }
         PermissionModel().set_new_user_perms(
             User.get_default_user(), _form_result)
         Session().commit()
 
         # make sure inherit flag is turned on
         self.u1.inherit_default_permissions = True
         Session().commit()
 
         # TODO(marcink): check branch perms
 
         # this user will have inherited permissions from default user
         assert global_perms(self.u1) == {
             'hg.create.none',
             'hg.fork.none',
             'hg.register.manual_activate',
             'hg.password_reset.enabled',
             'hg.extern_activate.auto',
             'repository.read',
             'group.read',
             'usergroup.read',
             'branch.push_force',
             'hg.create.write_on_repogroup.true',
             'hg.usergroup.create.false',
             'hg.repogroup.create.false',
             perm
         }
 
         assert set(repo_perms(self.u1).values()) == set([expected_perm])
 
     def test_repo_owner_permissions_not_overwritten_by_group(self):
         # create repo as USER,
         self.test_repo = fixture.create_repo(name='myownrepo',
                                              repo_type='hg',
                                              cur_user=self.u1)
 
         # he has permissions of admin as owner
         assert repo_perms(self.u1)['myownrepo'] == 'repository.admin'
 
         # set his permission as user group, he should still be admin
         self.ug1 = fixture.create_user_group('G1')
         UserGroupModel().add_user_to_group(self.ug1, self.u1)
         RepoModel().grant_user_group_permission(
             self.test_repo,
             group_name=self.ug1,
             perm='repository.none')
         Session().commit()
 
         assert repo_perms(self.u1)['myownrepo'] == 'repository.admin'
 
     def test_repo_owner_permissions_not_overwritten_by_others(self):
         # create repo as USER,
         self.test_repo = fixture.create_repo(name='myownrepo',
                                              repo_type='hg',
                                              cur_user=self.u1)
 
         # he has permissions of admin as owner
         assert repo_perms(self.u1)['myownrepo'] == 'repository.admin'
 
         # set his permission as user, he should still be admin
         RepoModel().grant_user_permission(
             self.test_repo, user=self.u1, perm='repository.none')
         Session().commit()
 
         assert repo_perms(self.u1)['myownrepo'] == 'repository.admin'
 
     def test_repo_group_owner_permissions_not_overwritten_by_group(self):
         # "u1" shall be owner without any special permission assigned
         self.g1 = fixture.create_repo_group('test1')
 
         # Make user group and grant a permission to user group
         self.ug1 = fixture.create_user_group('G1')
         UserGroupModel().add_user_to_group(self.ug1, self.u1)
         RepoGroupModel().grant_user_group_permission(
             repo_group=self.g1, group_name=self.ug1, perm='group.write')
 
         # Verify that user does not get any special permission if he is not
         # owner
         assert group_perms(self.u1) == {'test1': 'group.write'}
 
         # Make him owner of the repo group
         self.g1.user = self.u1
         assert group_perms(self.u1) == {'test1': 'group.admin'}
 
     def test_repo_group_owner_permissions_not_overwritten_by_others(self):
         # "u1" shall be owner without any special permission assigned
         self.g1 = fixture.create_repo_group('test1')
         RepoGroupModel().grant_user_permission(
             repo_group=self.g1, user=self.u1, perm='group.write')
 
         # Verify that user does not get any special permission if he is not
         # owner
         assert group_perms(self.u1) == {'test1': 'group.write'}
 
         # Make him owner of the repo group
         self.g1.user = self.u1
         assert group_perms(self.u1) == {u'test1': 'group.admin'}
 
     def _test_def_user_perm_equal(
             self, user, change_factor=0, compare_keys=None):
         perms = UserToPerm.query().filter(UserToPerm.user == user).all()
         assert len(perms) == \
             len(Permission.DEFAULT_USER_PERMISSIONS) + change_factor
         if compare_keys:
             assert set(
                 x.permissions.permission_name for x in perms) == compare_keys
 
     def _test_def_user_group_perm_equal(
             self, user_group, change_factor=0, compare_keys=None):
         perms = UserGroupToPerm.query().filter(
             UserGroupToPerm.users_group == user_group).all()
         assert len(perms) == \
             len(Permission.DEFAULT_USER_PERMISSIONS) + change_factor
         if compare_keys:
             assert set(
                 x.permissions.permission_name for x in perms) == compare_keys
 
     def test_set_default_permissions(self):
         PermissionModel().create_default_user_permissions(user=self.u1)
         self._test_def_user_perm_equal(user=self.u1)
 
     def test_set_default_permissions_after_one_is_missing(self):
         PermissionModel().create_default_user_permissions(user=self.u1)
         self._test_def_user_perm_equal(user=self.u1)
         # now we delete one, it should be re-created after another call
         perms = UserToPerm.query().filter(UserToPerm.user == self.u1).all()
         Session().delete(perms[0])
         Session().commit()
 
         self._test_def_user_perm_equal(user=self.u1, change_factor=-1)
 
         # create missing one !
         PermissionModel().create_default_user_permissions(user=self.u1)
         self._test_def_user_perm_equal(user=self.u1)
 
     @pytest.mark.parametrize("perm, modify_to", [
         ('repository.read', 'repository.none'),
         ('group.read', 'group.none'),
         ('usergroup.read', 'usergroup.none'),
         ('hg.create.repository', 'hg.create.none'),
         ('hg.fork.repository', 'hg.fork.none'),
         ('hg.register.manual_activate', 'hg.register.auto_activate',)
     ])
     def test_set_default_permissions_after_modification(self, perm, modify_to):
         PermissionModel().create_default_user_permissions(user=self.u1)
         self._test_def_user_perm_equal(user=self.u1)
 
         old = Permission.get_by_key(perm)
         new = Permission.get_by_key(modify_to)
         assert old is not None
         assert new is not None
 
         # now modify permissions
         p = UserToPerm.query().filter(
             UserToPerm.user == self.u1).filter(
             UserToPerm.permission == old).one()
         p.permission = new
         Session().add(p)
         Session().commit()
 
         PermissionModel().create_default_user_permissions(user=self.u1)
         self._test_def_user_perm_equal(user=self.u1)
 
     def test_clear_user_perms(self):
         PermissionModel().create_default_user_permissions(user=self.u1)
         self._test_def_user_perm_equal(user=self.u1)
 
         # now clear permissions
         cleared = PermissionModel()._clear_user_perms(self.u1.user_id)
         self._test_def_user_perm_equal(user=self.u1,
                                        change_factor=len(cleared)*-1)
 
     def test_clear_user_group_perms(self):
         self.ug1 = fixture.create_user_group('G1')
         PermissionModel().create_default_user_group_permissions(
             user_group=self.ug1)
         self._test_def_user_group_perm_equal(user_group=self.ug1)
 
         # now clear permissions
         cleared = PermissionModel()._clear_user_group_perms(
             self.ug1.users_group_id)
         self._test_def_user_group_perm_equal(user_group=self.ug1,
                                              change_factor=len(cleared)*-1)
 
     @pytest.mark.parametrize("form_result", [
         {},
         {'default_repo_create': 'hg.create.repository'},
         {'default_repo_create': 'hg.create.repository',
          'default_repo_perm': 'repository.read'},
         {'default_repo_create': 'hg.create.none',
          'default_repo_perm': 'repository.write',
          'default_fork_create': 'hg.fork.none'},
     ])
     def test_set_new_user_permissions(self, form_result):
         _form_result = {}
         _form_result.update(form_result)
         PermissionModel().set_new_user_perms(self.u1, _form_result)
         Session().commit()
         change_factor = -1 * (len(Permission.DEFAULT_USER_PERMISSIONS)
                               - len(form_result.keys()))
         self._test_def_user_perm_equal(
             self.u1, change_factor=change_factor)
 
     @pytest.mark.parametrize("form_result", [
         {},
         {'default_repo_create': 'hg.create.repository'},
         {'default_repo_create': 'hg.create.repository',
          'default_repo_perm': 'repository.read'},
         {'default_repo_create': 'hg.create.none',
          'default_repo_perm': 'repository.write',
          'default_fork_create': 'hg.fork.none'},
     ])
     def test_set_new_user_group_permissions(self, form_result):
         _form_result = {}
         _form_result.update(form_result)
         self.ug1 = fixture.create_user_group('G1')
         PermissionModel().set_new_user_group_perms(self.ug1, _form_result)
         Session().commit()
         change_factor = -1 * (len(Permission.DEFAULT_USER_PERMISSIONS)
                               - len(form_result.keys()))
         self._test_def_user_group_perm_equal(
             self.ug1, change_factor=change_factor)
 
     @pytest.mark.parametrize("group_active, expected_perm", [
         (True, 'repository.admin'),
         (False, 'repository.read'),
     ])
     def test_get_default_repo_perms_from_user_group_with_active_group(
             self, backend, user_util, group_active, expected_perm):
         repo = backend.create_repo()
         user = user_util.create_user()
         user_group = user_util.create_user_group(
             members=[user], users_group_active=group_active)
 
         user_util.grant_user_group_permission_to_repo(
             repo, user_group, 'repository.admin')
         permissions = repo_perms(user)
         repo_permission = permissions.get(repo.repo_name)
         assert repo_permission == expected_perm
 
     @pytest.mark.parametrize("group_active, expected_perm", [
         (True, 'group.admin'),
         (False, 'group.read')
     ])
     def test_get_default_group_perms_from_user_group_with_active_group(
             self, user_util, group_active, expected_perm):
         user = user_util.create_user()
         repo_group = user_util.create_repo_group()
         user_group = user_util.create_user_group(
             members=[user], users_group_active=group_active)
 
         user_util.grant_user_group_permission_to_repo_group(
             repo_group, user_group, 'group.admin')
         permissions = group_perms(user)
         group_permission = permissions.get(repo_group.name)
         assert group_permission == expected_perm
 
     @pytest.mark.parametrize("group_active, expected_perm", [
         (True, 'usergroup.admin'),
         (False, 'usergroup.read')
     ])
     def test_get_default_user_group_perms_from_user_group_with_active_group(
             self, user_util, group_active, expected_perm):
         user = user_util.create_user()
         user_group = user_util.create_user_group(
             members=[user], users_group_active=group_active)
         target_user_group = user_util.create_user_group()
 
         user_util.grant_user_group_permission_to_user_group(
             target_user_group, user_group, 'usergroup.admin')
         permissions = user_group_perms(user)
         group_permission = permissions.get(target_user_group.users_group_name)
         assert group_permission == expected_perm
 
 
 def repo_perms(user):
     auth_user = AuthUser(user_id=user.user_id)
     return auth_user.permissions['repositories']
 
 
 def branch_perms(user):
     auth_user = AuthUser(user_id=user.user_id)
     return auth_user.permissions['repository_branches']
 
 
 def group_perms(user):
     auth_user = AuthUser(user_id=user.user_id)
     return auth_user.permissions['repositories_groups']
 
 
 def user_group_perms(user):
     auth_user = AuthUser(user_id=user.user_id)
     return auth_user.permissions['user_groups']
 
 
 def global_perms(user):
     auth_user = AuthUser(user_id=user.user_id)
     return auth_user.permissions['global']
 
 
 def default_perms(added=None, removed=None):
     expected_perms = set(Permission.DEFAULT_USER_PERMISSIONS)
     if removed:
         expected_perms.difference_update(removed)
     if added:
         expected_perms.update(added)
     return expected_perms

rhodecode/tests/models/test_pullrequest.py

@@ -1,949 +1,949 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 import textwrap
 
 import rhodecode
 from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.backends.base import (
     MergeResponse, MergeFailureReason, Reference)
 from rhodecode.lib.vcs.exceptions import RepositoryError
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import PullRequest, Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 
 
 pytestmark = [
     pytest.mark.backends("git", "hg"),
 ]
 
 
 @pytest.mark.usefixtures('config_stub')
 class TestPullRequestModel(object):
 
-    @pytest.fixture
+    @pytest.fixture()
     def pull_request(self, request, backend, pr_util):
         """
         A pull request combined with multiples patches.
         """
         BackendClass = get_backend(backend.alias)
         merge_resp = MergeResponse(
             False, False, None, MergeFailureReason.UNKNOWN,
             metadata={'exception': 'MockError'})
         self.merge_patcher = mock.patch.object(
             BackendClass, 'merge', return_value=merge_resp)
         self.workspace_remove_patcher = mock.patch.object(
             BackendClass, 'cleanup_merge_workspace')
 
         self.workspace_remove_mock = self.workspace_remove_patcher.start()
         self.merge_mock = self.merge_patcher.start()
         self.comment_patcher = mock.patch(
             'rhodecode.model.changeset_status.ChangesetStatusModel.set_status')
         self.comment_patcher.start()
         self.notification_patcher = mock.patch(
             'rhodecode.model.notification.NotificationModel.create')
         self.notification_patcher.start()
         self.helper_patcher = mock.patch(
             'rhodecode.lib.helpers.route_path')
         self.helper_patcher.start()
 
         self.hook_patcher = mock.patch.object(PullRequestModel,
                                               'trigger_pull_request_hook')
         self.hook_mock = self.hook_patcher.start()
 
         self.invalidation_patcher = mock.patch(
             'rhodecode.model.pull_request.ScmModel.mark_for_invalidation')
         self.invalidation_mock = self.invalidation_patcher.start()
 
         self.pull_request = pr_util.create_pull_request(
             mergeable=True, name_suffix=u'ąć')
         self.source_commit = self.pull_request.source_ref_parts.commit_id
         self.target_commit = self.pull_request.target_ref_parts.commit_id
         self.workspace_id = 'pr-%s' % self.pull_request.pull_request_id
         self.repo_id = self.pull_request.target_repo.repo_id
 
         @request.addfinalizer
         def cleanup_pull_request():
             calls = [mock.call(
                 self.pull_request, self.pull_request.author, 'create')]
             self.hook_mock.assert_has_calls(calls)
 
             self.workspace_remove_patcher.stop()
             self.merge_patcher.stop()
             self.comment_patcher.stop()
             self.notification_patcher.stop()
             self.helper_patcher.stop()
             self.hook_patcher.stop()
             self.invalidation_patcher.stop()
 
         return self.pull_request
 
     def test_get_all(self, pull_request):
         prs = PullRequestModel().get_all(pull_request.target_repo)
         assert isinstance(prs, list)
         assert len(prs) == 1
 
     def test_count_all(self, pull_request):
         pr_count = PullRequestModel().count_all(pull_request.target_repo)
         assert pr_count == 1
 
     def test_get_awaiting_review(self, pull_request):
         prs = PullRequestModel().get_awaiting_review(pull_request.target_repo)
         assert isinstance(prs, list)
         assert len(prs) == 1
 
     def test_count_awaiting_review(self, pull_request):
         pr_count = PullRequestModel().count_awaiting_review(
             pull_request.target_repo)
         assert pr_count == 1
 
     def test_get_awaiting_my_review(self, pull_request):
         PullRequestModel().update_reviewers(
             pull_request, [(pull_request.author, ['author'], False, [])],
             pull_request.author)
         prs = PullRequestModel().get_awaiting_my_review(
             pull_request.target_repo, user_id=pull_request.author.user_id)
         assert isinstance(prs, list)
         assert len(prs) == 1
 
     def test_count_awaiting_my_review(self, pull_request):
         PullRequestModel().update_reviewers(
             pull_request, [(pull_request.author, ['author'], False, [])],
             pull_request.author)
         pr_count = PullRequestModel().count_awaiting_my_review(
             pull_request.target_repo, user_id=pull_request.author.user_id)
         assert pr_count == 1
 
     def test_delete_calls_cleanup_merge(self, pull_request):
         repo_id = pull_request.target_repo.repo_id
         PullRequestModel().delete(pull_request, pull_request.author)
 
         self.workspace_remove_mock.assert_called_once_with(
             repo_id, self.workspace_id)
 
     def test_close_calls_cleanup_and_hook(self, pull_request):
         PullRequestModel().close_pull_request(
             pull_request, pull_request.author)
         repo_id = pull_request.target_repo.repo_id
 
         self.workspace_remove_mock.assert_called_once_with(
             repo_id, self.workspace_id)
         self.hook_mock.assert_called_with(
             self.pull_request, self.pull_request.author, 'close')
 
     def test_merge_status(self, pull_request):
         self.merge_mock.return_value = MergeResponse(
             True, False, None, MergeFailureReason.NONE)
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
         assert pull_request.last_merge_status is None
 
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is True
         assert msg == 'This pull request can be automatically merged.'
         self.merge_mock.assert_called_with(
             self.repo_id, self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts, dry_run=True,
             use_rebase=False, close_branch=False)
 
         assert pull_request._last_merge_source_rev == self.source_commit
         assert pull_request._last_merge_target_rev == self.target_commit
         assert pull_request.last_merge_status is MergeFailureReason.NONE
 
         self.merge_mock.reset_mock()
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is True
         assert msg == 'This pull request can be automatically merged.'
         assert self.merge_mock.called is False
 
     def test_merge_status_known_failure(self, pull_request):
         self.merge_mock.return_value = MergeResponse(
             False, False, None, MergeFailureReason.MERGE_FAILED)
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
         assert pull_request.last_merge_status is None
 
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
         assert msg == 'This pull request cannot be merged because of merge conflicts.'
         self.merge_mock.assert_called_with(
             self.repo_id, self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts, dry_run=True,
             use_rebase=False, close_branch=False)
 
         assert pull_request._last_merge_source_rev == self.source_commit
         assert pull_request._last_merge_target_rev == self.target_commit
         assert (
             pull_request.last_merge_status is MergeFailureReason.MERGE_FAILED)
 
         self.merge_mock.reset_mock()
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
         assert msg == 'This pull request cannot be merged because of merge conflicts.'
         assert self.merge_mock.called is False
 
     def test_merge_status_unknown_failure(self, pull_request):
         self.merge_mock.return_value = MergeResponse(
             False, False, None, MergeFailureReason.UNKNOWN,
             metadata={'exception': 'MockError'})
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
         assert pull_request.last_merge_status is None
 
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
         assert msg == (
             'This pull request cannot be merged because of an unhandled exception. '
             'MockError')
         self.merge_mock.assert_called_with(
             self.repo_id, self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts, dry_run=True,
             use_rebase=False, close_branch=False)
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
         assert pull_request.last_merge_status is None
 
         self.merge_mock.reset_mock()
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
         assert msg == (
             'This pull request cannot be merged because of an unhandled exception. '
             'MockError')
         assert self.merge_mock.called is True
 
     def test_merge_status_when_target_is_locked(self, pull_request):
         pull_request.target_repo.locked = [1, u'12345.50', 'lock_web']
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
         assert msg == (
             'This pull request cannot be merged because the target repository '
             'is locked by user:1.')
 
     def test_merge_status_requirements_check_target(self, pull_request):
 
         def has_largefiles(self, repo):
             return repo == pull_request.source_repo
 
         patcher = mock.patch.object(PullRequestModel, '_has_largefiles', has_largefiles)
         with patcher:
             status, msg = PullRequestModel().merge_status(pull_request)
 
         assert status is False
         assert msg == 'Target repository large files support is disabled.'
 
     def test_merge_status_requirements_check_source(self, pull_request):
 
         def has_largefiles(self, repo):
             return repo == pull_request.target_repo
 
         patcher = mock.patch.object(PullRequestModel, '_has_largefiles', has_largefiles)
         with patcher:
             status, msg = PullRequestModel().merge_status(pull_request)
 
         assert status is False
         assert msg == 'Source repository large files support is disabled.'
 
     def test_merge(self, pull_request, merge_extras):
         user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         merge_ref = Reference(
             'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
         self.merge_mock.return_value = MergeResponse(
             True, True, merge_ref, MergeFailureReason.NONE)
 
         merge_extras['repository'] = pull_request.target_repo.repo_name
         PullRequestModel().merge_repo(
             pull_request, pull_request.author, extras=merge_extras)
 
         message = (
             u'Merge pull request #{pr_id} from {source_repo} {source_ref_name}'
             u'\n\n {pr_title}'.format(
                 pr_id=pull_request.pull_request_id,
                 source_repo=safe_unicode(
                     pull_request.source_repo.scm_instance().name),
                 source_ref_name=pull_request.source_ref_parts.name,
                 pr_title=safe_unicode(pull_request.title)
             )
         )
         self.merge_mock.assert_called_with(
             self.repo_id, self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts,
             user_name=user.short_contact, user_email=user.email, message=message,
             use_rebase=False, close_branch=False
         )
         self.invalidation_mock.assert_called_once_with(
             pull_request.target_repo.repo_name)
 
         self.hook_mock.assert_called_with(
             self.pull_request, self.pull_request.author, 'merge')
 
         pull_request = PullRequest.get(pull_request.pull_request_id)
         assert pull_request.merge_rev == '6126b7bfcc82ad2d3deaee22af926b082ce54cc6'
 
     def test_merge_with_status_lock(self, pull_request, merge_extras):
         user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         merge_ref = Reference(
             'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
         self.merge_mock.return_value = MergeResponse(
             True, True, merge_ref, MergeFailureReason.NONE)
 
         merge_extras['repository'] = pull_request.target_repo.repo_name
 
         with pull_request.set_state(PullRequest.STATE_UPDATING):
             assert pull_request.pull_request_state == PullRequest.STATE_UPDATING
             PullRequestModel().merge_repo(
                 pull_request, pull_request.author, extras=merge_extras)
 
         assert pull_request.pull_request_state == PullRequest.STATE_CREATED
 
         message = (
             u'Merge pull request #{pr_id} from {source_repo} {source_ref_name}'
             u'\n\n {pr_title}'.format(
                 pr_id=pull_request.pull_request_id,
                 source_repo=safe_unicode(
                     pull_request.source_repo.scm_instance().name),
                 source_ref_name=pull_request.source_ref_parts.name,
                 pr_title=safe_unicode(pull_request.title)
             )
         )
         self.merge_mock.assert_called_with(
             self.repo_id, self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts,
             user_name=user.short_contact, user_email=user.email, message=message,
             use_rebase=False, close_branch=False
         )
         self.invalidation_mock.assert_called_once_with(
             pull_request.target_repo.repo_name)
 
         self.hook_mock.assert_called_with(
             self.pull_request, self.pull_request.author, 'merge')
 
         pull_request = PullRequest.get(pull_request.pull_request_id)
         assert pull_request.merge_rev == '6126b7bfcc82ad2d3deaee22af926b082ce54cc6'
 
     def test_merge_failed(self, pull_request, merge_extras):
         user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         merge_ref = Reference(
             'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
         self.merge_mock.return_value = MergeResponse(
             False, False, merge_ref, MergeFailureReason.MERGE_FAILED)
 
         merge_extras['repository'] = pull_request.target_repo.repo_name
         PullRequestModel().merge_repo(
             pull_request, pull_request.author, extras=merge_extras)
 
         message = (
             u'Merge pull request #{pr_id} from {source_repo} {source_ref_name}'
             u'\n\n {pr_title}'.format(
                 pr_id=pull_request.pull_request_id,
                 source_repo=safe_unicode(
                     pull_request.source_repo.scm_instance().name),
                 source_ref_name=pull_request.source_ref_parts.name,
                 pr_title=safe_unicode(pull_request.title)
             )
         )
         self.merge_mock.assert_called_with(
             self.repo_id, self.workspace_id,
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts,
             user_name=user.short_contact, user_email=user.email, message=message,
             use_rebase=False, close_branch=False
         )
 
         pull_request = PullRequest.get(pull_request.pull_request_id)
         assert self.invalidation_mock.called is False
         assert pull_request.merge_rev is None
 
     def test_get_commit_ids(self, pull_request):
         # The PR has been not merget yet, so expect an exception
         with pytest.raises(ValueError):
             PullRequestModel()._get_commit_ids(pull_request)
 
         # Merge revision is in the revisions list
         pull_request.merge_rev = pull_request.revisions[0]
         commit_ids = PullRequestModel()._get_commit_ids(pull_request)
         assert commit_ids == pull_request.revisions
 
         # Merge revision is not in the revisions list
         pull_request.merge_rev = 'f000' * 10
         commit_ids = PullRequestModel()._get_commit_ids(pull_request)
         assert commit_ids == pull_request.revisions + [pull_request.merge_rev]
 
     def test_get_diff_from_pr_version(self, pull_request):
         source_repo = pull_request.source_repo
         source_ref_id = pull_request.source_ref_parts.commit_id
         target_ref_id = pull_request.target_ref_parts.commit_id
         diff = PullRequestModel()._get_diff_from_pr_or_version(
             source_repo, source_ref_id, target_ref_id,
             hide_whitespace_changes=False, diff_context=6)
         assert 'file_1' in diff.raw
 
     def test_generate_title_returns_unicode(self):
         title = PullRequestModel().generate_pullrequest_title(
             source='source-dummy',
             source_ref='source-ref-dummy',
             target='target-dummy',
         )
         assert type(title) == unicode
 
 
 @pytest.mark.usefixtures('config_stub')
 class TestIntegrationMerge(object):
     @pytest.mark.parametrize('extra_config', (
         {'vcs.hooks.protocol': 'http', 'vcs.hooks.direct_calls': False},
     ))
     def test_merge_triggers_push_hooks(
             self, pr_util, user_admin, capture_rcextensions, merge_extras,
             extra_config):
 
         pull_request = pr_util.create_pull_request(
             approved=True, mergeable=True)
         # TODO: johbo: Needed for sqlite, try to find an automatic way for it
         merge_extras['repository'] = pull_request.target_repo.repo_name
         Session().commit()
 
         with mock.patch.dict(rhodecode.CONFIG, extra_config, clear=False):
             merge_state = PullRequestModel().merge_repo(
                 pull_request, user_admin, extras=merge_extras)
 
         assert merge_state.executed
         assert '_pre_push_hook' in capture_rcextensions
         assert '_push_hook' in capture_rcextensions
 
     def test_merge_can_be_rejected_by_pre_push_hook(
             self, pr_util, user_admin, capture_rcextensions, merge_extras):
         pull_request = pr_util.create_pull_request(
             approved=True, mergeable=True)
         # TODO: johbo: Needed for sqlite, try to find an automatic way for it
         merge_extras['repository'] = pull_request.target_repo.repo_name
         Session().commit()
 
         with mock.patch('rhodecode.EXTENSIONS.PRE_PUSH_HOOK') as pre_pull:
             pre_pull.side_effect = RepositoryError("Disallow push!")
             merge_status = PullRequestModel().merge_repo(
                 pull_request, user_admin, extras=merge_extras)
 
         assert not merge_status.executed
         assert 'pre_push' not in capture_rcextensions
         assert 'post_push' not in capture_rcextensions
 
     def test_merge_fails_if_target_is_locked(
             self, pr_util, user_regular, merge_extras):
         pull_request = pr_util.create_pull_request(
             approved=True, mergeable=True)
         locked_by = [user_regular.user_id + 1, 12345.50, 'lock_web']
         pull_request.target_repo.locked = locked_by
         # TODO: johbo: Check if this can work based on the database, currently
         # all data is pre-computed, that's why just updating the DB is not
         # enough.
         merge_extras['locked_by'] = locked_by
         merge_extras['repository'] = pull_request.target_repo.repo_name
         # TODO: johbo: Needed for sqlite, try to find an automatic way for it
         Session().commit()
         merge_status = PullRequestModel().merge_repo(
             pull_request, user_regular, extras=merge_extras)
         assert not merge_status.executed
 
 
 @pytest.mark.parametrize('use_outdated, inlines_count, outdated_count', [
     (False, 1, 0),
     (True, 0, 1),
 ])
 def test_outdated_comments(
         pr_util, use_outdated, inlines_count, outdated_count, config_stub):
     pull_request = pr_util.create_pull_request()
     pr_util.create_inline_comment(file_path='not_in_updated_diff')
 
     with outdated_comments_patcher(use_outdated) as outdated_comment_mock:
         pr_util.add_one_commit()
         assert_inline_comments(
             pull_request, visible=inlines_count, outdated=outdated_count)
     outdated_comment_mock.assert_called_with(pull_request)
 
 
 @pytest.mark.parametrize('mr_type, expected_msg', [
     (MergeFailureReason.NONE,
      'This pull request can be automatically merged.'),
     (MergeFailureReason.UNKNOWN,
      'This pull request cannot be merged because of an unhandled exception. CRASH'),
     (MergeFailureReason.MERGE_FAILED,
      'This pull request cannot be merged because of merge conflicts.'),
     (MergeFailureReason.PUSH_FAILED,
      'This pull request could not be merged because push to target:`some-repo@merge_commit` failed.'),
     (MergeFailureReason.TARGET_IS_NOT_HEAD,
      'This pull request cannot be merged because the target `ref_name` is not a head.'),
     (MergeFailureReason.HG_SOURCE_HAS_MORE_BRANCHES,
      'This pull request cannot be merged because the source contains more branches than the target.'),
     (MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS,
      'This pull request cannot be merged because the target `ref_name` has multiple heads: `a,b,c`.'),
     (MergeFailureReason.TARGET_IS_LOCKED,
      'This pull request cannot be merged because the target repository is locked by user:123.'),
     (MergeFailureReason.MISSING_TARGET_REF,
      'This pull request cannot be merged because the target reference `ref_name` is missing.'),
     (MergeFailureReason.MISSING_SOURCE_REF,
      'This pull request cannot be merged because the source reference `ref_name` is missing.'),
     (MergeFailureReason.SUBREPO_MERGE_FAILED,
      'This pull request cannot be merged because of conflicts related to sub repositories.'),
 
 ])
 def test_merge_response_message(mr_type, expected_msg):
     merge_ref = Reference('type', 'ref_name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
     metadata = {
         'exception': "CRASH",
         'target': 'some-repo',
         'merge_commit': 'merge_commit',
         'target_ref': merge_ref,
         'source_ref': merge_ref,
         'heads': ','.join(['a', 'b', 'c']),
         'locked_by': 'user:123'}
 
     merge_response = MergeResponse(True, True, merge_ref, mr_type, metadata=metadata)
     assert merge_response.merge_status_message == expected_msg
 
 
[e-mail]
[e-mail]()
 def merge_extras(user_regular):
     """
     Context for the vcs operation when running a merge.
     """
     extras = {
         'ip': '127.0.0.1',
         'username': user_regular.username,
         'user_id': user_regular.user_id,
         'action': 'push',
         'repository': 'fake_target_repo_name',
         'scm': 'git',
         'config': 'fake_config_ini_path',
         'repo_store': '',
         'make_lock': None,
         'locked_by': [None, None, None],
         'server_url': 'http://test.example.com:5000',
         'hooks': ['push', 'pull'],
         'is_shadow_repo': False,
     }
     return extras
 
 
 @pytest.mark.usefixtures('config_stub')
 class TestUpdateCommentHandling(object):
 
     @pytest.fixture(autouse=True, scope='class')
     def enable_outdated_comments(self, request, baseapp):
         config_patch = mock.patch.dict(
             'rhodecode.CONFIG', {'rhodecode_use_outdated_comments': True})
         config_patch.start()
 
         @request.addfinalizer
         def cleanup():
             config_patch.stop()
 
     def test_comment_stays_unflagged_on_unchanged_diff(self, pr_util):
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [FileNode('file_b', 'test_content\n')]},
             {'message': 'c', 'added': [FileNode('file_c', 'test_content\n')]},
         ]
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'])
         pr_util.create_inline_comment(file_path='file_b')
         pr_util.add_one_commit(head='c')
 
         assert_inline_comments(pull_request, visible=1, outdated=0)
 
     def test_comment_stays_unflagged_on_change_above(self, pr_util):
         original_content = ''.join(
             ['line {}\n'.format(x) for x in range(1, 11)])
         updated_content = 'new_line_at_top\n' + original_content
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [FileNode('file_b', original_content)]},
             {'message': 'c', 'changed': [FileNode('file_b', updated_content)]},
         ]
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'])
 
         with outdated_comments_patcher():
             comment = pr_util.create_inline_comment(
                 line_no=u'n8', file_path='file_b')
             pr_util.add_one_commit(head='c')
 
         assert_inline_comments(pull_request, visible=1, outdated=0)
         assert comment.line_no == u'n9'
 
     def test_comment_stays_unflagged_on_change_below(self, pr_util):
         original_content = ''.join(['line {}\n'.format(x) for x in range(10)])
         updated_content = original_content + 'new_line_at_end\n'
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [FileNode('file_b', original_content)]},
             {'message': 'c', 'changed': [FileNode('file_b', updated_content)]},
         ]
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'])
         pr_util.create_inline_comment(file_path='file_b')
         pr_util.add_one_commit(head='c')
 
         assert_inline_comments(pull_request, visible=1, outdated=0)
 
     @pytest.mark.parametrize('line_no', ['n4', 'o4', 'n10', 'o9'])
     def test_comment_flagged_on_change_around_context(self, pr_util, line_no):
         base_lines = ['line {}\n'.format(x) for x in range(1, 13)]
         change_lines = list(base_lines)
         change_lines.insert(6, 'line 6a added\n')
 
         # Changes on the last line of sight
         update_lines = list(change_lines)
         update_lines[0] = 'line 1 changed\n'
         update_lines[-1] = 'line 12 changed\n'
 
         def file_b(lines):
             return FileNode('file_b', ''.join(lines))
 
         commits = [
             {'message': 'a', 'added': [file_b(base_lines)]},
             {'message': 'b', 'changed': [file_b(change_lines)]},
             {'message': 'c', 'changed': [file_b(update_lines)]},
         ]
 
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'])
         pr_util.create_inline_comment(line_no=line_no, file_path='file_b')
 
         with outdated_comments_patcher():
             pr_util.add_one_commit(head='c')
             assert_inline_comments(pull_request, visible=0, outdated=1)
 
     @pytest.mark.parametrize("change, content", [
         ('changed', 'changed\n'),
         ('removed', ''),
     ], ids=['changed', 'removed'])
     def test_comment_flagged_on_change(self, pr_util, change, content):
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [FileNode('file_b', 'test_content\n')]},
             {'message': 'c', change: [FileNode('file_b', content)]},
         ]
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'])
         pr_util.create_inline_comment(file_path='file_b')
 
         with outdated_comments_patcher():
             pr_util.add_one_commit(head='c')
             assert_inline_comments(pull_request, visible=0, outdated=1)
 
 
 @pytest.mark.usefixtures('config_stub')
 class TestUpdateChangedFiles(object):
 
     def test_no_changes_on_unchanged_diff(self, pr_util):
         commits = [
             {'message': 'a'},
             {'message': 'b',
              'added': [FileNode('file_b', 'test_content b\n')]},
             {'message': 'c',
              'added': [FileNode('file_c', 'test_content c\n')]},
         ]
         # open a PR from a to b, adding file_b
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'],
             name_suffix='per-file-review')
 
         # modify PR adding new file file_c
         pr_util.add_one_commit(head='c')
 
         assert_pr_file_changes(
             pull_request,
             added=['file_c'],
             modified=[],
             removed=[])
 
     def test_modify_and_undo_modification_diff(self, pr_util):
         commits = [
             {'message': 'a'},
             {'message': 'b',
              'added': [FileNode('file_b', 'test_content b\n')]},
             {'message': 'c',
              'changed': [FileNode('file_b', 'test_content b modified\n')]},
             {'message': 'd',
              'changed': [FileNode('file_b', 'test_content b\n')]},
         ]
         # open a PR from a to b, adding file_b
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'],
             name_suffix='per-file-review')
 
         # modify PR modifying file file_b
         pr_util.add_one_commit(head='c')
 
         assert_pr_file_changes(
             pull_request,
             added=[],
             modified=['file_b'],
             removed=[])
 
         # move the head again to d, which rollbacks change,
         # meaning we should indicate no changes
         pr_util.add_one_commit(head='d')
 
         assert_pr_file_changes(
             pull_request,
             added=[],
             modified=[],
             removed=[])
 
     def test_updated_all_files_in_pr(self, pr_util):
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [
                 FileNode('file_a', 'test_content a\n'),
                 FileNode('file_b', 'test_content b\n'),
                 FileNode('file_c', 'test_content c\n')]},
             {'message': 'c', 'changed': [
                 FileNode('file_a', 'test_content a changed\n'),
                 FileNode('file_b', 'test_content b changed\n'),
                 FileNode('file_c', 'test_content c changed\n')]},
         ]
         # open a PR from a to b, changing 3 files
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'],
             name_suffix='per-file-review')
 
         pr_util.add_one_commit(head='c')
 
         assert_pr_file_changes(
             pull_request,
             added=[],
             modified=['file_a', 'file_b', 'file_c'],
             removed=[])
 
     def test_updated_and_removed_all_files_in_pr(self, pr_util):
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [
                 FileNode('file_a', 'test_content a\n'),
                 FileNode('file_b', 'test_content b\n'),
                 FileNode('file_c', 'test_content c\n')]},
             {'message': 'c', 'removed': [
                 FileNode('file_a', 'test_content a changed\n'),
                 FileNode('file_b', 'test_content b changed\n'),
                 FileNode('file_c', 'test_content c changed\n')]},
         ]
         # open a PR from a to b, removing 3 files
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'],
             name_suffix='per-file-review')
 
         pr_util.add_one_commit(head='c')
 
         assert_pr_file_changes(
             pull_request,
             added=[],
             modified=[],
             removed=['file_a', 'file_b', 'file_c'])
 
 
 def test_update_writes_snapshot_into_pull_request_version(pr_util, config_stub):
     model = PullRequestModel()
     pull_request = pr_util.create_pull_request()
     pr_util.update_source_repository()
 
     model.update_commits(pull_request)
 
     # Expect that it has a version entry now
     assert len(model.get_versions(pull_request)) == 1
 
 
 def test_update_skips_new_version_if_unchanged(pr_util, config_stub):
     pull_request = pr_util.create_pull_request()
     model = PullRequestModel()
     model.update_commits(pull_request)
 
     # Expect that it still has no versions
     assert len(model.get_versions(pull_request)) == 0
 
 
 def test_update_assigns_comments_to_the_new_version(pr_util, config_stub):
     model = PullRequestModel()
     pull_request = pr_util.create_pull_request()
     comment = pr_util.create_comment()
     pr_util.update_source_repository()
 
     model.update_commits(pull_request)
 
     # Expect that the comment is linked to the pr version now
     assert comment.pull_request_version == model.get_versions(pull_request)[0]
 
 
 def test_update_adds_a_comment_to_the_pull_request_about_the_change(pr_util, config_stub):
     model = PullRequestModel()
     pull_request = pr_util.create_pull_request()
     pr_util.update_source_repository()
     pr_util.update_source_repository()
 
     model.update_commits(pull_request)
 
     # Expect to find a new comment about the change
     expected_message = textwrap.dedent(
         """\
         Pull request updated. Auto status change to |under_review|
 
         .. role:: added
         .. role:: removed
         .. parsed-literal::
 
           Changed commits:
             * :added:`1 added`
             * :removed:`0 removed`
 
           Changed files:
             * `A file_2 <#a_c--92ed3b5f07b4>`_
 
         .. |under_review| replace:: *"Under Review"*"""
     )
     pull_request_comments = sorted(
         pull_request.comments, key=lambda c: c.modified_at)
     update_comment = pull_request_comments[-1]
     assert update_comment.text == expected_message
 
 
 def test_create_version_from_snapshot_updates_attributes(pr_util, config_stub):
     pull_request = pr_util.create_pull_request()
 
     # Avoiding default values
     pull_request.status = PullRequest.STATUS_CLOSED
     pull_request._last_merge_source_rev = "0" * 40
     pull_request._last_merge_target_rev = "1" * 40
     pull_request.last_merge_status = 1
     pull_request.merge_rev = "2" * 40
 
     # Remember automatic values
     created_on = pull_request.created_on
     updated_on = pull_request.updated_on
 
     # Create a new version of the pull request
     version = PullRequestModel()._create_version_from_snapshot(pull_request)
 
     # Check attributes
     assert version.title == pr_util.create_parameters['title']
     assert version.description == pr_util.create_parameters['description']
     assert version.status == PullRequest.STATUS_CLOSED
 
     # versions get updated created_on
     assert version.created_on != created_on
 
     assert version.updated_on == updated_on
     assert version.user_id == pull_request.user_id
     assert version.revisions == pr_util.create_parameters['revisions']
     assert version.source_repo == pr_util.source_repository
     assert version.source_ref == pr_util.create_parameters['source_ref']
     assert version.target_repo == pr_util.target_repository
     assert version.target_ref == pr_util.create_parameters['target_ref']
     assert version._last_merge_source_rev == pull_request._last_merge_source_rev
     assert version._last_merge_target_rev == pull_request._last_merge_target_rev
     assert version.last_merge_status == pull_request.last_merge_status
     assert version.merge_rev == pull_request.merge_rev
     assert version.pull_request == pull_request
 
 
 def test_link_comments_to_version_only_updates_unlinked_comments(pr_util, config_stub):
     version1 = pr_util.create_version_of_pull_request()
     comment_linked = pr_util.create_comment(linked_to=version1)
     comment_unlinked = pr_util.create_comment()
     version2 = pr_util.create_version_of_pull_request()
 
     PullRequestModel()._link_comments_to_version(version2)
 
     # Expect that only the new comment is linked to version2
     assert (
         comment_unlinked.pull_request_version_id ==
         version2.pull_request_version_id)
     assert (
         comment_linked.pull_request_version_id ==
         version1.pull_request_version_id)
     assert (
         comment_unlinked.pull_request_version_id !=
         comment_linked.pull_request_version_id)
 
 
 def test_calculate_commits():
     old_ids = [1, 2, 3]
     new_ids = [1, 3, 4, 5]
     change = PullRequestModel()._calculate_commit_id_changes(old_ids, new_ids)
     assert change.added == [4, 5]
     assert change.common == [1, 3]
     assert change.removed == [2]
     assert change.total == [1, 3, 4, 5]
 
 
 def assert_inline_comments(pull_request, visible=None, outdated=None):
     if visible is not None:
         inline_comments = CommentsModel().get_inline_comments(
             pull_request.target_repo.repo_id, pull_request=pull_request)
         inline_cnt = CommentsModel().get_inline_comments_count(
             inline_comments)
         assert inline_cnt == visible
     if outdated is not None:
         outdated_comments = CommentsModel().get_outdated_comments(
             pull_request.target_repo.repo_id, pull_request)
         assert len(outdated_comments) == outdated
 
 
 def assert_pr_file_changes(
         pull_request, added=None, modified=None, removed=None):
     pr_versions = PullRequestModel().get_versions(pull_request)
     # always use first version, ie original PR to calculate changes
     pull_request_version = pr_versions[0]
     old_diff_data, new_diff_data = PullRequestModel()._generate_update_diffs(
         pull_request, pull_request_version)
     file_changes = PullRequestModel()._calculate_file_changes(
         old_diff_data, new_diff_data)
 
     assert added == file_changes.added, \
         'expected added:%s vs value:%s' % (added, file_changes.added)
     assert modified == file_changes.modified, \
         'expected modified:%s vs value:%s' % (modified, file_changes.modified)
     assert removed == file_changes.removed, \
         'expected removed:%s vs value:%s' % (removed, file_changes.removed)
 
 
 def outdated_comments_patcher(use_outdated=True):
     return mock.patch.object(
         CommentsModel, 'use_outdated_comments',
         return_value=use_outdated)

rhodecode/tests/models/test_repo_readme.py

@@ -1,106 +1,106 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
 
 from rhodecode.lib.vcs import nodes
 from rhodecode.model.repo import ReadmeFinder
 
 
[e-mail]
[e-mail]()
 def commit_util(vcsbackend_stub):
     """
     Provide a commit which has certain files in it's tree.
 
     This is based on the fixture "vcsbackend" and will automatically be
     parametrized for all vcs backends.
     """
     return CommitUtility(vcsbackend_stub)
 
 
 class CommitUtility:
 
     def __init__(self, vcsbackend):
         self.vcsbackend = vcsbackend
 
     def commit_with_files(self, filenames):
         commits = [
             {'message': 'Adding all requested files',
              'added': [
                  nodes.FileNode(filename, content='')
                  for filename in filenames
              ]}]
         repo = self.vcsbackend.create_repo(commits=commits)
         return repo.get_commit()
 
 
 def test_no_matching_file_returns_none(commit_util):
     commit = commit_util.commit_with_files(['LIESMICH'])
     finder = ReadmeFinder(default_renderer='rst')
     filenode = finder.search(commit)
     assert filenode is None
 
 
 def test_matching_file_returns_the_file_name(commit_util):
     commit = commit_util.commit_with_files(['README'])
     finder = ReadmeFinder(default_renderer='rst')
     filenode = finder.search(commit)
     assert filenode.path == 'README'
 
 
 def test_matching_file_with_extension(commit_util):
     commit = commit_util.commit_with_files(['README.rst'])
     finder = ReadmeFinder(default_renderer='rst')
     filenode = finder.search(commit)
     assert filenode.path == 'README.rst'
 
 
 def test_prefers_readme_without_extension(commit_util):
     commit = commit_util.commit_with_files(['README.rst', 'Readme'])
     finder = ReadmeFinder()
     filenode = finder.search(commit)
     assert filenode.path == 'Readme'
 
 
 @pytest.mark.parametrize('renderer, expected', [
     ('rst', 'readme.rst'),
     ('markdown', 'readme.md'),
 ])
 def test_prefers_renderer_extensions(commit_util, renderer, expected):
     commit = commit_util.commit_with_files(
         ['readme.rst', 'readme.md', 'readme.txt'])
     finder = ReadmeFinder(default_renderer=renderer)
     filenode = finder.search(commit)
     assert filenode.path == expected
 
 
 def test_finds_readme_in_subdirectory(commit_util):
     commit = commit_util.commit_with_files(['doc/README.rst', 'LIESMICH'])
     finder = ReadmeFinder()
     filenode = finder.search(commit)
     assert filenode.path == 'doc/README.rst'
 
 
 def test_prefers_subdirectory_with_priority(commit_util):
     commit = commit_util.commit_with_files(
         ['Doc/Readme.rst', 'Docs/Readme.rst'])
     finder = ReadmeFinder()
     filenode = finder.search(commit)
     assert filenode.path == 'Doc/Readme.rst'

rhodecode/tests/models/test_users.py

@@ -1,328 +1,328 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
 import mock
 
 from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.model.db import (
     true, User, UserGroup, UserGroupMember, UserEmailMap, Permission, UserIpMap)
 from rhodecode.model.meta import Session
 from rhodecode.model.user import UserModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.tests.fixture import Fixture
 
 fixture = Fixture()
 
 
 class TestGetUsers(object):
     def test_returns_active_users(self, backend, user_util):
         for i in range(4):
             is_active = i % 2 == 0
             user_util.create_user(active=is_active, lastname='Fake user')
 
         with mock.patch('rhodecode.lib.helpers.gravatar_url'):
             with mock.patch('rhodecode.lib.helpers.link_to_user'):
                 users = UserModel().get_users()
         fake_users = [u for u in users if u['last_name'] == 'Fake user']
         assert len(fake_users) == 2
 
         expected_keys = (
             'id', 'first_name', 'last_name', 'username', 'icon_link',
             'value_display', 'value', 'value_type')
         for user in users:
             assert user['value_type'] is 'user'
             for key in expected_keys:
                 assert key in user
 
     def test_returns_user_filtered_by_last_name(self, backend, user_util):
         keywords = ('aBc', u'ünicode')
         for keyword in keywords:
             for i in range(2):
                 user_util.create_user(
                     active=True, lastname=u'Fake {} user'.format(keyword))
 
         with mock.patch('rhodecode.lib.helpers.gravatar_url'):
             with mock.patch('rhodecode.lib.helpers.link_to_user'):
                 keyword = keywords[1].lower()
                 users = UserModel().get_users(name_contains=keyword)
 
         fake_users = [u for u in users if u['last_name'].startswith('Fake')]
         assert len(fake_users) == 2
         for user in fake_users:
             assert user['last_name'] == safe_unicode('Fake ünicode user')
 
     def test_returns_user_filtered_by_first_name(self, backend, user_util):
         created_users = []
         keywords = ('aBc', u'ünicode')
         for keyword in keywords:
             for i in range(2):
                 created_users.append(user_util.create_user(
                     active=True, lastname='Fake user',
                     firstname=u'Fake {} user'.format(keyword)))
 
         keyword = keywords[1].lower()
         with mock.patch('rhodecode.lib.helpers.gravatar_url'):
             with mock.patch('rhodecode.lib.helpers.link_to_user'):
                 users = UserModel().get_users(name_contains=keyword)
 
         fake_users = [u for u in users if u['last_name'].startswith('Fake')]
         assert len(fake_users) == 2
         for user in fake_users:
             assert user['first_name'] == safe_unicode('Fake ünicode user')
 
     def test_returns_user_filtered_by_username(self, backend, user_util):
         created_users = []
         for i in range(5):
             created_users.append(user_util.create_user(
                 active=True, lastname='Fake user'))
 
         user_filter = created_users[-1].username[-2:]
         with mock.patch('rhodecode.lib.helpers.gravatar_url'):
             with mock.patch('rhodecode.lib.helpers.link_to_user'):
                 users = UserModel().get_users(name_contains=user_filter)
 
         fake_users = [u for u in users if u['last_name'].startswith('Fake')]
         assert len(fake_users) == 1
         assert fake_users[0]['username'] == created_users[-1].username
 
     def test_returns_limited_user_list(self, backend, user_util):
         created_users = []
         for i in range(5):
             created_users.append(user_util.create_user(
                 active=True, lastname='Fake user'))
 
         with mock.patch('rhodecode.lib.helpers.gravatar_url'):
             with mock.patch('rhodecode.lib.helpers.link_to_user'):
                 users = UserModel().get_users(name_contains='Fake', limit=3)
 
         fake_users = [u for u in users if u['last_name'].startswith('Fake')]
         assert len(fake_users) == 3
 
 
[e-mail]
[e-mail]()
 def test_user(request, baseapp):
     usr = UserModel().create_or_update(
         username=u'test_user',
         password=u'qweqwe',
         email=u'[e-mail]',
         firstname=u'u1', lastname=u'u1')
     Session().commit()
     assert User.get_by_username(u'test_user') == usr
 
     @request.addfinalizer
     def cleanup():
         if UserModel().get_user(usr.user_id) is None:
             return
 
         perm = Permission.query().all()
         for p in perm:
             UserModel().revoke_perm(usr, p)
 
         UserModel().delete(usr.user_id)
         Session().commit()
 
     return usr
 
 
 def test_create_and_remove(test_user):
     usr = test_user
 
     # make user group
     user_group = fixture.create_user_group('some_example_group')
     Session().commit()
 
     UserGroupModel().add_user_to_group(user_group, usr)
     Session().commit()
 
     assert UserGroup.get(user_group.users_group_id) == user_group
     assert UserGroupMember.query().count() == 1
     UserModel().delete(usr.user_id)
     Session().commit()
 
     assert UserGroupMember.query().all() == []
 
 
 def test_additonal_email_as_main(test_user):
     with pytest.raises(AttributeError):
         m = UserEmailMap()
         m.email = test_user.email
         m.user = test_user
         Session().add(m)
         Session().commit()
 
 
 def test_extra_email_map(test_user):
 
     m = UserEmailMap()
     m.email = u'[e-mail]'
     m.user = test_user
     Session().add(m)
     Session().commit()
 
     u = User.get_by_email(email='[e-mail]')
     assert test_user.user_id == u.user_id
     assert test_user.username == u.username
 
     u = User.get_by_email(email='[e-mail]')
     assert test_user.user_id == u.user_id
     assert test_user.username == u.username
     u = User.get_by_email(email='[e-mail]')
     assert u is None
 
 
 def test_get_api_data_replaces_secret_data_by_default(test_user):
     api_data = test_user.get_api_data()
     api_key_length = 40
     expected_replacement = '*' * api_key_length
 
     for key in api_data['auth_tokens']:
         assert key == expected_replacement
 
 
 def test_get_api_data_includes_secret_data_if_activated(test_user):
     api_data = test_user.get_api_data(include_secrets=True)
     assert api_data['auth_tokens'] == test_user.auth_tokens
 
 
 def test_add_perm(test_user):
     perm = Permission.query().all()[0]
     UserModel().grant_perm(test_user, perm)
     Session().commit()
     assert UserModel().has_perm(test_user, perm)
 
 
 def test_has_perm(test_user):
     perm = Permission.query().all()
     for p in perm:
         assert not UserModel().has_perm(test_user, p)
 
 
 def test_revoke_perm(test_user):
     perm = Permission.query().all()[0]
     UserModel().grant_perm(test_user, perm)
     Session().commit()
     assert UserModel().has_perm(test_user, perm)
 
     # revoke
     UserModel().revoke_perm(test_user, perm)
     Session().commit()
     assert not UserModel().has_perm(test_user, perm)
 
 
 @pytest.mark.parametrize("ip_range, expected, expect_errors", [
     ('', [], False),
     ('127.0.0.1', ['127.0.0.1'], False),
     ('127.0.0.1,127.0.0.2', ['127.0.0.1', '127.0.0.2'], False),
     ('127.0.0.1 ,  127.0.0.2', ['127.0.0.1', '127.0.0.2'], False),
     (
         '127.0.0.1,172.172.172.0,127.0.0.2',
         ['127.0.0.1', '172.172.172.0', '127.0.0.2'], False),
     (
         '127.0.0.1-127.0.0.5',
         ['127.0.0.1', '127.0.0.2', '127.0.0.3', '127.0.0.4', '127.0.0.5'],
         False),
     (
         '127.0.0.1 - 127.0.0.5',
         ['127.0.0.1', '127.0.0.2', '127.0.0.3', '127.0.0.4', '127.0.0.5'],
         False
     ),
     ('-', [], True),
     ('127.0.0.1-32', [], True),
     (
         '127.0.0.1,127.0.0.1,127.0.0.1,127.0.0.1-127.0.0.2,127.0.0.2',
         ['127.0.0.1', '127.0.0.2'], False),
     (
         '127.0.0.1-127.0.0.2,127.0.0.4-127.0.0.6,',
         ['127.0.0.1', '127.0.0.2', '127.0.0.4', '127.0.0.5', '127.0.0.6'],
         False
     ),
     (
         '127.0.0.1-127.0.0.2,127.0.0.1-127.0.0.6,',
         ['127.0.0.1', '127.0.0.2', '127.0.0.3', '127.0.0.4', '127.0.0.5',
          '127.0.0.6'],
         False
     ),
 ])
 def test_ip_range_generator(ip_range, expected, expect_errors):
     func = UserModel().parse_ip_range
     if expect_errors:
         pytest.raises(ValueError, func, ip_range)
     else:
         parsed_list = func(ip_range)
         assert parsed_list == expected
 
 
 def test_user_delete_cascades_ip_whitelist(test_user):
     sample_ip = '1.1.1.1'
     uid_map = UserIpMap(user_id=test_user.user_id, ip_addr=sample_ip)
     Session().add(uid_map)
     Session().delete(test_user)
     try:
         Session().flush()
     finally:
         Session().rollback()
 
 
 def test_account_for_deactivation_generation(test_user):
     accounts = UserModel().get_accounts_in_creation_order(
         current_user=test_user)
     # current user should be #1 in the list
     assert accounts[0] == test_user.user_id
     active_users = User.query().filter(User.active == true()).count()
     assert active_users == len(accounts)
 
 
 def test_user_delete_cascades_permissions_on_repo(backend, test_user):
     test_repo = backend.create_repo()
     RepoModel().grant_user_permission(
         test_repo, test_user, 'repository.write')
     Session().commit()
 
     assert test_user.repo_to_perm
 
     UserModel().delete(test_user)
     Session().commit()
 
 
 def test_user_delete_cascades_permissions_on_repo_group(
         test_repo_group, test_user):
     RepoGroupModel().grant_user_permission(
         test_repo_group, test_user, 'group.write')
     Session().commit()
 
     assert test_user.repo_group_to_perm
 
     Session().delete(test_user)
     Session().commit()
 
 
 def test_user_delete_cascades_permissions_on_user_group(
         test_user_group, test_user):
     UserGroupModel().grant_user_permission(
         test_user_group, test_user, 'usergroup.write')
     Session().commit()
 
     assert test_user.user_group_to_perm
 
     Session().delete(test_user)
     Session().commit()

rhodecode/tests/other/test_validators.py

@@ -1,296 +1,296 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import formencode
 import pytest
 
 from rhodecode.tests import (
     HG_REPO, TEST_USER_REGULAR2_EMAIL, TEST_USER_REGULAR2_LOGIN,
     TEST_USER_REGULAR2_PASS, TEST_USER_ADMIN_LOGIN, TESTS_TMP_PATH)
 
 from rhodecode.model import validators as v
 from rhodecode.model.user_group import UserGroupModel
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.db import ChangesetStatus, Repository
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.tests.fixture import Fixture
 
 fixture = Fixture()
 
 pytestmark = pytest.mark.usefixtures('baseapp')
 
 
[e-mail]
[e-mail]()
 def localizer():
     def func(msg):
         return msg
     return func
 
 
 def test_Message_extractor(localizer):
     validator = v.ValidUsername(localizer)
     pytest.raises(formencode.Invalid, validator.to_python, 'default')
 
     class StateObj(object):
         pass
 
     pytest.raises(
         formencode.Invalid, validator.to_python, 'default', StateObj)
 
 
 def test_ValidUsername(localizer):
     validator = v.ValidUsername(localizer)
 
     pytest.raises(formencode.Invalid, validator.to_python, 'default')
     pytest.raises(formencode.Invalid, validator.to_python, 'new_user')
     pytest.raises(formencode.Invalid, validator.to_python, '.,')
     pytest.raises(
         formencode.Invalid, validator.to_python, TEST_USER_ADMIN_LOGIN)
     assert 'test' == validator.to_python('test')
 
     validator = v.ValidUsername(localizer, edit=True, old_data={'user_id': 1})
 
 
 def test_ValidRepoUser(localizer):
     validator = v.ValidRepoUser(localizer)
     pytest.raises(formencode.Invalid, validator.to_python, 'nouser')
     assert TEST_USER_ADMIN_LOGIN == \
         validator.to_python(TEST_USER_ADMIN_LOGIN)
 
 
 def test_ValidUserGroup(localizer):
     validator = v.ValidUserGroup(localizer)
     pytest.raises(formencode.Invalid, validator.to_python, 'default')
     pytest.raises(formencode.Invalid, validator.to_python, '.,')
 
     gr = fixture.create_user_group('test')
     gr2 = fixture.create_user_group('tes2')
     Session().commit()
     pytest.raises(formencode.Invalid, validator.to_python, 'test')
     assert gr.users_group_id is not None
     validator = v.ValidUserGroup(localizer,
         edit=True,
         old_data={'users_group_id': gr2.users_group_id})
 
     pytest.raises(formencode.Invalid, validator.to_python, 'test')
     pytest.raises(formencode.Invalid, validator.to_python, 'TesT')
     pytest.raises(formencode.Invalid, validator.to_python, 'TEST')
     UserGroupModel().delete(gr)
     UserGroupModel().delete(gr2)
     Session().commit()
 
 
 @pytest.fixture(scope='function')
 def repo_group(request):
     model = RepoGroupModel()
     gr = model.create(
         group_name='test_gr', group_description='desc', just_db=True,
         owner=TEST_USER_ADMIN_LOGIN)
 
     def cleanup():
         model.delete(gr)
 
     request.addfinalizer(cleanup)
 
     return gr
 
 
 def test_ValidRepoGroup_same_name_as_repo(localizer):
     validator = v.ValidRepoGroup(localizer)
     with pytest.raises(formencode.Invalid) as excinfo:
         validator.to_python({'group_name': HG_REPO})
     expected_msg = 'Repository with name "vcs_test_hg" already exists'
     assert expected_msg in str(excinfo.value)
 
 
 def test_ValidRepoGroup_group_exists(localizer, repo_group):
     validator = v.ValidRepoGroup(localizer)
     with pytest.raises(formencode.Invalid) as excinfo:
         validator.to_python({'group_name': repo_group.group_name})
     expected_msg = 'Group "test_gr" already exists'
     assert expected_msg in str(excinfo.value)
 
 
 def test_ValidRepoGroup_invalid_parent(localizer, repo_group):
     validator = v.ValidRepoGroup(localizer, edit=True,
                                  old_data={'group_id': repo_group.group_id})
     with pytest.raises(formencode.Invalid) as excinfo:
         validator.to_python({
             'group_name': repo_group.group_name + 'n',
             'group_parent_id': repo_group.group_id,
         })
     expected_msg = 'Cannot assign this group as parent'
     assert expected_msg in str(excinfo.value)
 
 
 def test_ValidRepoGroup_edit_group_no_root_permission(localizer, repo_group):
     validator = v.ValidRepoGroup(localizer,
         edit=True, old_data={'group_id': repo_group.group_id},
         can_create_in_root=False)
 
     # Cannot change parent
     with pytest.raises(formencode.Invalid) as excinfo:
         validator.to_python({'group_parent_id': '25'})
     expected_msg = 'no permission to store repository group in root location'
     assert expected_msg in str(excinfo.value)
 
     # Chaning all the other fields is allowed
     validator.to_python({'group_name': 'foo', 'group_parent_id': '-1'})
     validator.to_python(
         {'user': TEST_USER_REGULAR2_LOGIN, 'group_parent_id': '-1'})
     validator.to_python({'group_description': 'bar', 'group_parent_id': '-1'})
     validator.to_python({'enable_locking': 'true', 'group_parent_id': '-1'})
 
 
 def test_ValidPassword(localizer):
     validator = v.ValidPassword(localizer)
     assert 'lol' == validator.to_python('lol')
     assert None == validator.to_python(None)
     pytest.raises(formencode.Invalid, validator.to_python, 'ąćżź')
 
 
 def test_ValidPasswordsMatch(localizer):
     validator = v.ValidPasswordsMatch(localizer)
     pytest.raises(
         formencode.Invalid,
         validator.to_python, {'password': 'pass',
                               'password_confirmation': 'pass2'})
 
     pytest.raises(
         formencode.Invalid,
         validator.to_python, {'new_password': 'pass',
                               'password_confirmation': 'pass2'})
 
     assert {'new_password': 'pass', 'password_confirmation': 'pass'} == \
         validator.to_python({'new_password': 'pass',
                              'password_confirmation': 'pass'})
 
     assert {'password': 'pass', 'password_confirmation': 'pass'} == \
         validator.to_python({'password': 'pass',
                              'password_confirmation': 'pass'})
 
 
 def test_ValidAuth(localizer, config_stub):
     config_stub.testing_securitypolicy()
     config_stub.include('rhodecode.authentication')
     config_stub.include('rhodecode.authentication.plugins.auth_rhodecode')
     config_stub.include('rhodecode.authentication.plugins.auth_token')
 
     validator = v.ValidAuth(localizer)
     valid_creds = {
         'username': TEST_USER_REGULAR2_LOGIN,
         'password': TEST_USER_REGULAR2_PASS,
     }
     invalid_creds = {
         'username': 'err',
         'password': 'err',
     }
     assert valid_creds == validator.to_python(valid_creds)
     pytest.raises(
         formencode.Invalid, validator.to_python, invalid_creds)
 
 
 def test_ValidRepoName(localizer):
     validator = v.ValidRepoName(localizer)
 
     pytest.raises(
         formencode.Invalid, validator.to_python, {'repo_name': ''})
 
     pytest.raises(
         formencode.Invalid, validator.to_python, {'repo_name': HG_REPO})
 
     gr = RepoGroupModel().create(group_name='group_test',
                                  group_description='desc',
                                  owner=TEST_USER_ADMIN_LOGIN)
     pytest.raises(
         formencode.Invalid, validator.to_python, {'repo_name': gr.group_name})
 
     #TODO: write an error case for that ie. create a repo withinh a group
 #        pytest.raises(formencode.Invalid,
 #                          validator.to_python, {'repo_name': 'some',
 #                                                'repo_group': gr.group_id})
 
 
 def test_ValidForkName(localizer):
     # this uses ValidRepoName validator
     assert True
 
 @pytest.mark.parametrize("name, expected", [
     ('test', 'test'), ('lolz!', 'lolz'), ('  aavv', 'aavv'),
     ('ala ma kota', 'ala-ma-kota'), ('@nooo', 'nooo'),
     ('$!haha lolz !', 'haha-lolz'), ('$$$$$', ''), ('{}OK!', 'OK'),
     ('/]re po', 're-po')])
 def test_SlugifyName(name, expected, localizer):
     validator = v.SlugifyName(localizer)
     assert expected == validator.to_python(name)
 
 
 def test_ValidForkType(localizer):
         validator = v.ValidForkType(localizer, old_data={'repo_type': 'hg'})
         assert 'hg' == validator.to_python('hg')
         pytest.raises(formencode.Invalid, validator.to_python, 'git')
 
 
 def test_ValidPath(localizer):
         validator = v.ValidPath(localizer)
         assert TESTS_TMP_PATH == validator.to_python(TESTS_TMP_PATH)
         pytest.raises(
             formencode.Invalid, validator.to_python, '/no_such_dir')
 
 
 def test_UniqSystemEmail(localizer):
     validator = v.UniqSystemEmail(localizer, old_data={})
 
     assert '[e-mail]' == validator.to_python('[e-mail]')
 
     email = TEST_USER_REGULAR2_EMAIL
     pytest.raises(formencode.Invalid, validator.to_python, email)
 
 
 def test_ValidSystemEmail(localizer):
     validator = v.ValidSystemEmail(localizer)
     email = TEST_USER_REGULAR2_EMAIL
 
     assert email == validator.to_python(email)
     pytest.raises(formencode.Invalid, validator.to_python, 'err')
 
 
 def test_NotReviewedRevisions(localizer):
     repo_id = Repository.get_by_repo_name(HG_REPO).repo_id
     validator = v.NotReviewedRevisions(localizer, repo_id)
     rev = '0' * 40
     # add status for a rev, that should throw an error because it is already
     # reviewed
     new_status = ChangesetStatus()
     new_status.author = ChangesetStatusModel()._get_user(TEST_USER_ADMIN_LOGIN)
     new_status.repo = ChangesetStatusModel()._get_repo(HG_REPO)
     new_status.status = ChangesetStatus.STATUS_APPROVED
     new_status.comment = None
     new_status.revision = rev
     Session().add(new_status)
     Session().commit()
     try:
         pytest.raises(formencode.Invalid, validator.to_python, [rev])
     finally:
         Session().delete(new_status)
         Session().commit()

rhodecode/tests/plugin.py

@@ -1,1826 +1,1826 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import collections
 import datetime
 import hashlib
 import os
 import re
 import pprint
 import shutil
 import socket
 import subprocess32
 import time
 import uuid
 import dateutil.tz
 import functools
 
 import mock
 import pyramid.testing
 import pytest
 import colander
 import requests
 import pyramid.paster
 
 import rhodecode
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
     PullRequest, Repository, RhodeCodeSetting, ChangesetStatus, RepoGroup,
     UserGroup, RepoRhodeCodeUi, RepoRhodeCodeSetting, RhodeCodeUi)
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.settings import VcsSettingsModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
 from rhodecode.lib.utils import repo2db_mapper
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.tests import (
     login_user_session, get_new_dir, utils, TESTS_TMP_PATH,
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR2_LOGIN,
     TEST_USER_REGULAR_PASS)
 from rhodecode.tests.utils import CustomTestApp, set_anonymous_access
 from rhodecode.tests.fixture import Fixture
 from rhodecode.config import utils as config_utils
 
 def _split_comma(value):
     return value.split(',')
 
 
 def pytest_addoption(parser):
     parser.addoption(
         '--keep-tmp-path', action='store_true',
         help="Keep the test temporary directories")
     parser.addoption(
         '--backends', action='store', type=_split_comma,
         default=['git', 'hg', 'svn'],
         help="Select which backends to test for backend specific tests.")
     parser.addoption(
         '--dbs', action='store', type=_split_comma,
         default=['sqlite'],
         help="Select which database to test for database specific tests. "
              "Possible options are sqlite,postgres,mysql")
     parser.addoption(
         '--appenlight', '--ae', action='store_true',
         help="Track statistics in appenlight.")
     parser.addoption(
         '--appenlight-api-key', '--ae-key',
         help="API key for Appenlight.")
     parser.addoption(
         '--appenlight-url', '--ae-url',
         default="https://ae.rhodecode.com",
         help="Appenlight service URL, defaults to https://ae.rhodecode.com")
     parser.addoption(
         '--sqlite-connection-string', action='store',
         default='', help="Connection string for the dbs tests with SQLite")
     parser.addoption(
         '--postgres-connection-string', action='store',
         default='', help="Connection string for the dbs tests with Postgres")
     parser.addoption(
         '--mysql-connection-string', action='store',
         default='', help="Connection string for the dbs tests with MySQL")
     parser.addoption(
         '--repeat', type=int, default=100,
         help="Number of repetitions in performance tests.")
 
 
 def pytest_configure(config):
     from rhodecode.config import patches
 
 
 def pytest_collection_modifyitems(session, config, items):
     # nottest marked, compare nose, used for transition from nose to pytest
     remaining = [
         i for i in items if getattr(i.obj, '__test__', True)]
     items[:] = remaining
 
 
 def pytest_generate_tests(metafunc):
     # Support test generation based on --backend parameter
     if 'backend_alias' in metafunc.fixturenames:
         backends = get_backends_from_metafunc(metafunc)
         scope = None
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
         metafunc.parametrize('backend_alias', backends, scope=scope)
     elif hasattr(metafunc.function, 'backends'):
         backends = get_backends_from_metafunc(metafunc)
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
 
 
 def get_backends_from_metafunc(metafunc):
     requested_backends = set(metafunc.config.getoption('--backends'))
     if hasattr(metafunc.function, 'backends'):
         # Supported backends by this test function, created from
         # pytest.mark.backends
         backends = metafunc.definition.get_closest_marker('backends').args
     elif hasattr(metafunc.cls, 'backend_alias'):
         # Support class attribute "backend_alias", this is mainly
         # for legacy reasons for tests not yet using pytest.mark.backends
         backends = [metafunc.cls.backend_alias]
     else:
         backends = metafunc.config.getoption('--backends')
     return requested_backends.intersection(backends)
 
 
 @pytest.fixture(scope='session', autouse=True)
 def activate_example_rcextensions(request):
     """
     Patch in an example rcextensions module which verifies passed in kwargs.
     """
     from rhodecode.config import rcextensions
 
     old_extensions = rhodecode.EXTENSIONS
     rhodecode.EXTENSIONS = rcextensions
     rhodecode.EXTENSIONS.calls = collections.defaultdict(list)
 
     @request.addfinalizer
     def cleanup():
         rhodecode.EXTENSIONS = old_extensions
 
 
[e-mail]
[e-mail]()
 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'
 
 
[e-mail]
[e-mail]()
 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]
 
 
[e-mail]
[e-mail]()
 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'
     }
 
 
[e-mail]
[e-mail]()
 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
 
     print("Using the RhodeCode configuration:{}".format(ini_config))
     pyramid.paster.setup_logging(ini_config)
 
     settings = get_app_config(ini_config)
     app = make_pyramid_app({'__file__': ini_config}, **settings)
 
     return app
 
 
 @pytest.fixture(scope='function')
 def app(request, config_stub, baseapp, http_environ):
     app = CustomTestApp(
         baseapp,
         extra_environ=http_environ)
     if request.cls:
         request.cls.app = app
     return app
 
 
 @pytest.fixture(scope='session')
 def app_settings(baseapp, ini_config):
     """
     Settings dictionary used to create the app.
 
     Parses the ini file and passes the result through the sanitize and apply
     defaults mechanism in `rhodecode.config.middleware`.
     """
     return baseapp.config.get_settings()
 
 
 @pytest.fixture(scope='session')
 def db_connection(ini_settings):
     # Initialize the database connection.
     config_utils.initialize_database(ini_settings)
 
 
 LoginData = collections.namedtuple('LoginData', ('csrf_token', 'user'))
 
 
 def _autologin_user(app, *args):
     session = login_user_session(app, *args)
     csrf_token = rhodecode.lib.auth.get_csrf_token(session)
     return LoginData(csrf_token, session['rhodecode_user'])
 
 
[e-mail]
[e-mail]()
 def autologin_user(app):
     """
     Utility fixture which makes sure that the admin user is logged in
     """
     return _autologin_user(app)
 
 
[e-mail]
[e-mail]()
 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'}
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 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)
 
 
[e-mail]
[e-mail]()
 def backend_git(request, baseapp, test_repo):
     return backend_base(request, 'git', baseapp, test_repo)
 
 
[e-mail]
[e-mail]()
 def backend_hg(request, baseapp, test_repo):
     return backend_base(request, 'hg', baseapp, test_repo)
 
 
[e-mail]
[e-mail]()
 def backend_svn(request, baseapp, test_repo):
     return backend_base(request, 'svn', baseapp, test_repo)
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 def repo_stub(backend_stub):
     """
     Use this to express that your tests need a repository stub
     """
     return backend_stub.create_repo()
 
 
 class Backend(object):
     """
     Represents the test configuration for one supported backend
 
     Provides easy access to different test repositories based on
     `__getitem__`. Such repositories will only be created once per test
     session.
     """
 
     invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
     _master_repo = None
     _commit_ids = {}
 
     def __init__(self, alias, repo_name, test_name, test_repo_container):
         self.alias = alias
         self.repo_name = repo_name
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
         # TODO: johbo: Used as a delegate interim. Not yet sure if Backend or
         # Fixture will survive in the end.
         self._fixture = Fixture()
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias)
 
     def create_test_repo(self, key, config=None):
         return self._test_repo_container(key, self.alias, config)
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo or the
         last repo which has been created with `create_repo`.
         """
         from rhodecode.model.db import Repository
         return Repository.get_by_repo_name(self.repo_name)
 
     @property
     def default_branch_name(self):
         VcsRepository = get_backend(self.alias)
         return VcsRepository.DEFAULT_BRANCH_NAME
 
     @property
     def default_head_id(self):
         """
         Returns the default head id of the underlying backend.
 
         This will be the default branch name in case the backend does have a
         default branch. In the other cases it will point to a valid head
         which can serve as the base to create a new commit on top of it.
         """
         vcsrepo = self.repo.scm_instance()
         head_id = (
             vcsrepo.DEFAULT_BRANCH_NAME or
             vcsrepo.commit_ids[-1])
         return head_id
 
     @property
     def commit_ids(self):
         """
         Returns the list of commits for the last created repository
         """
         return self._commit_ids
 
     def create_master_repo(self, commits):
         """
         Create a repository and remember it as a template.
 
         This allows to easily create derived repositories to construct
         more complex scenarios for diff, compare and pull requests.
 
         Returns a commit map which maps from commit message to raw_id.
         """
         self._master_repo = self.create_repo(commits=commits)
         return self._commit_ids
 
     def create_repo(
             self, commits=None, number_of_commits=0, heads=None,
             name_suffix=u'', 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`
         """
         vcsmaster = self._master_repo.scm_instance()
         vcsrepo = repo.scm_instance()
         vcsrepo.config.clear_section('hooks')
         commit_ids = [self._commit_ids[h] for h in heads]
         vcsrepo.pull(vcsmaster.path, commit_ids=commit_ids)
 
     def create_fork(self):
         repo_to_fork = self.repo_name
         self.repo_name = self._next_repo_name()
         repo = self._fixture.create_fork(repo_to_fork, self.repo_name)
         self._cleanup_repos.append(self.repo_name)
         return repo
 
     def new_repo_name(self, suffix=u''):
         self.repo_name = self._next_repo_name() + suffix
         self._cleanup_repos.append(self.repo_name)
         return self.repo_name
 
     def _next_repo_name(self):
         return u"%s_%s" % (
             self.invalid_repo_name.sub(u'_', self._test_name), len(self._cleanup_repos))
 
     def ensure_file(self, filename, content='Test content\n'):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         commits = [
             {'added': [
                 FileNode(filename, content=content),
             ]},
         ]
         self._add_commits_to_repo(self.repo.scm_instance(), commits)
 
     def enable_downloads(self):
         repo = self.repo
         repo.enable_downloads = True
         Session().add(repo)
         Session().commit()
 
     def cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
     def _add_commits_to_repo(self, repo, commits):
         commit_ids = _add_commits_to_repo(repo, commits)
         if not commit_ids:
             return
         self._commit_ids = commit_ids
 
         # Creating refs for Git to allow fetching them from remote repository
         if self.alias == 'git':
             refs = {}
             for message in self._commit_ids:
                 # TODO: mikhail: do more special chars replacements
                 ref_name = 'refs/test-refs/{}'.format(
                     message.replace(' ', ''))
                 refs[ref_name] = self._commit_ids[message]
             self._create_refs(repo, refs)
 
     def _create_refs(self, repo, refs):
         for ref_name in refs:
             repo.set_refs(ref_name, refs[ref_name])
 
 
 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
 
 
[e-mail]
[e-mail]()
 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)
 
 
[e-mail]
[e-mail]()
 def vcsbackend_git(request, tests_tmp_path, baseapp, test_repo):
     return vcsbackend_base(request, 'git', tests_tmp_path, baseapp, test_repo)
 
 
[e-mail]
[e-mail]()
 def vcsbackend_hg(request, tests_tmp_path, baseapp, test_repo):
     return vcsbackend_base(request, 'hg', tests_tmp_path, baseapp, test_repo)
 
 
[e-mail]
[e-mail]()
 def vcsbackend_svn(request, tests_tmp_path, baseapp, test_repo):
     return vcsbackend_base(request, 'svn', tests_tmp_path, baseapp, test_repo)
 
 
[e-mail]
[e-mail]()
 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 xrange(number_of_commits)]
         _add_commits_to_repo(repo, commits)
         return repo
 
     def clone_repo(self, repo):
         return self.create_repo(_clone_repo=repo)
 
     def cleanup(self):
         for repo in self._cleanup_repos:
             shutil.rmtree(repo.path)
 
     def new_repo_path(self):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         return self._repo_path
 
     def _next_repo_name(self):
         return "%s_%s" % (
             self.invalid_repo_name.sub('_', self._test_name),
             len(self._cleanup_repos))
 
     def add_file(self, repo, filename, content='Test content\n'):
         imc = repo.in_memory_commit
         imc.add(FileNode(filename, content=content))
         imc.commit(
             message=u'Automatic commit from vcsbackend fixture',
             author=u'Automatic <[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 = unicode(commit.get('message', 'Commit %s' % idx))
 
         for node in commit.get('added', []):
             imc.add(FileNode(node.path, content=node.content))
         for node in commit.get('changed', []):
             imc.change(FileNode(node.path, content=node.content))
         for node in commit.get('removed', []):
             imc.remove(FileNode(node.path))
 
         parents = [
             vcs_repo.get_commit(commit_id=commit_ids[p])
             for p in commit.get('parents', [])]
 
         operations = ('added', 'changed', 'removed')
         if not any((commit.get(o) for o in operations)):
             imc.add(FileNode('file_%s' % idx, content=message))
 
         commit = imc.commit(
             message=message,
             author=unicode(commit.get('author', 'Automatic <[e-mail]>')),
             date=commit.get('date'),
             branch=commit.get('branch'),
             parents=parents)
 
         commit_ids[commit.message] = commit.raw_id
 
     return commit_ids
 
 
[e-mail]
[e-mail]()
 def reposerver(request):
     """
     Allows to serve a backend repository
     """
 
     repo_server = RepoServer()
     request.addfinalizer(repo_server.cleanup)
     return repo_server
 
 
 class RepoServer(object):
     """
     Utility to serve a local repository for the duration of a test case.
 
     Supports only Subversion so far.
     """
 
     url = None
 
     def __init__(self):
         self._cleanup_servers = []
 
     def serve(self, vcsrepo):
         if vcsrepo.alias != 'svn':
             raise TypeError("Backend %s not supported" % vcsrepo.alias)
 
         proc = subprocess32.Popen(
             ['svnserve', '-d', '--foreground', '--listen-host', 'localhost',
              '--root', vcsrepo.path])
         self._cleanup_servers.append(proc)
         self.url = 'svn://localhost'
 
     def cleanup(self):
         for proc in self._cleanup_servers:
             proc.terminate()
 
 
[e-mail]
[e-mail]()
 def pr_util(backend, request, config_stub):
     """
     Utility for tests of models and for functional tests around pull requests.
 
     It gives an instance of :class:`PRTestUtility` which provides various
     utility methods around one pull request.
 
     This fixture uses `backend` and inherits its parameterization.
     """
 
     util = PRTestUtility(backend)
     request.addfinalizer(util.cleanup)
 
     return util
 
 
 class PRTestUtility(object):
 
     pull_request = None
     pull_request_id = None
     mergeable_patcher = None
     mergeable_mock = None
     notification_patcher = None
 
     def __init__(self, backend):
         self.backend = backend
 
     def create_pull_request(
             self, commits=None, target_head=None, source_head=None,
             revisions=None, approved=False, author=None, mergeable=False,
             enable_notifications=True, name_suffix=u'', reviewers=None,
             title=u"Test", description=u"Description"):
         self.set_mergeable(mergeable)
         if not enable_notifications:
             # mock notification side effect
             self.notification_patcher = mock.patch(
                 'rhodecode.model.notification.NotificationModel.create')
             self.notification_patcher.start()
 
         if not self.pull_request:
             if not commits:
                 commits = [
                     {'message': 'c1'},
                     {'message': 'c2'},
                     {'message': 'c3'},
                 ]
                 target_head = 'c1'
                 source_head = 'c2'
                 revisions = ['c2']
 
             self.commit_ids = self.backend.create_master_repo(commits)
             self.target_repository = self.backend.create_repo(
                 heads=[target_head], name_suffix=name_suffix)
             self.source_repository = self.backend.create_repo(
                 heads=[source_head], name_suffix=name_suffix)
             self.author = author or UserModel().get_by_username(
                 TEST_USER_ADMIN_LOGIN)
 
             model = PullRequestModel()
             self.create_parameters = {
                 'created_by': self.author,
                 'source_repo': self.source_repository.repo_name,
                 'source_ref': self._default_branch_reference(source_head),
                 'target_repo': self.target_repository.repo_name,
                 'target_ref': self._default_branch_reference(target_head),
                 'revisions': [self.commit_ids[r] for r in revisions],
                 'reviewers': reviewers or self._get_reviewers(),
                 'title': title,
                 'description': description,
             }
             self.pull_request = model.create(**self.create_parameters)
             assert model.get_versions(self.pull_request) == []
 
             self.pull_request_id = self.pull_request.pull_request_id
 
             if approved:
                 self.approve()
 
             Session().add(self.pull_request)
             Session().commit()
 
         return self.pull_request
 
     def approve(self):
         self.create_status_votes(
             ChangesetStatus.STATUS_APPROVED,
             *self.pull_request.reviewers)
 
     def close(self):
         PullRequestModel().close_pull_request(self.pull_request, self.author)
 
     def _default_branch_reference(self, commit_message):
         reference = '%s:%s:%s' % (
             'branch',
             self.backend.default_branch_name,
             self.commit_ids[commit_message])
         return reference
 
     def _get_reviewers(self):
         return [
             (TEST_USER_REGULAR_LOGIN, ['default1'], False, []),
             (TEST_USER_REGULAR2_LOGIN, ['default2'], False, []),
         ]
 
     def update_source_repository(self, head=None):
         heads = [head or 'c3']
         self.backend.pull_heads(self.source_repository, heads=heads)
 
     def add_one_commit(self, head=None):
         self.update_source_repository(head=head)
         old_commit_ids = set(self.pull_request.revisions)
         PullRequestModel().update_commits(self.pull_request)
         commit_ids = set(self.pull_request.revisions)
         new_commit_ids = commit_ids - old_commit_ids
         assert len(new_commit_ids) == 1
         return new_commit_ids.pop()
 
     def remove_one_commit(self):
         assert len(self.pull_request.revisions) == 2
         source_vcs = self.source_repository.scm_instance()
         removed_commit_id = source_vcs.commit_ids[-1]
 
         # TODO: johbo: Git and Mercurial have an inconsistent vcs api here,
         # remove the if once that's sorted out.
         if self.backend.alias == "git":
             kwargs = {'branch_name': self.backend.default_branch_name}
         else:
             kwargs = {}
         source_vcs.strip(removed_commit_id, **kwargs)
 
         PullRequestModel().update_commits(self.pull_request)
         assert len(self.pull_request.revisions) == 1
         return removed_commit_id
 
     def create_comment(self, linked_to=None):
         comment = CommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_inline_comment(
             self, linked_to=None, line_no=u'n1', file_path='file_1'):
         comment = CommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             line_no=line_no,
             f_path=file_path,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_version_of_pull_request(self):
         pull_request = self.create_pull_request()
         version = PullRequestModel()._create_version_from_snapshot(
             pull_request)
         return version
 
     def create_status_votes(self, status, *reviewers):
         for reviewer in reviewers:
             ChangesetStatusModel().set_status(
                 repo=self.pull_request.target_repo,
                 status=status,
                 user=reviewer.user_id,
                 pull_request=self.pull_request)
 
     def set_mergeable(self, value):
         if not self.mergeable_patcher:
             self.mergeable_patcher = mock.patch.object(
                 VcsSettingsModel, 'get_general_settings')
             self.mergeable_mock = self.mergeable_patcher.start()
         self.mergeable_mock.return_value = {
             'rhodecode_pr_merge_enabled': value}
 
     def cleanup(self):
         # In case the source repository is already cleaned up, the pull
         # request will already be deleted.
         pull_request = PullRequest().get(self.pull_request_id)
         if pull_request:
             PullRequestModel().delete(pull_request, pull_request.author)
             Session().commit()
 
         if self.notification_patcher:
             self.notification_patcher.stop()
 
         if self.mergeable_patcher:
             self.mergeable_patcher.stop()
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 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)
         for repo_group_id in sorted_repo_group_ids:
             self.fixture.destroy_repo_group(repo_group_id)
 
     def _cleanup_repos(self):
         sorted_repos_ids = sorted(self.repos_ids)
         for repo_id in sorted_repos_ids:
             self.fixture.destroy_repo(repo_id)
 
     def _cleanup_user_groups(self):
         def _user_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = UserGroup.get(first_group_id)
             second_group = UserGroup.get(second_group_id)
             first_group_parts = (
                 len(first_group.users_group_name.split('/'))
                 if first_group else 0)
             second_group_parts = (
                 len(second_group.users_group_name.split('/'))
                 if second_group else 0)
             return cmp(second_group_parts, first_group_parts)
 
         sorted_user_group_ids = sorted(
             self.user_group_ids, cmp=_user_group_compare)
         for user_group_id in sorted_user_group_ids:
             self.fixture.destroy_user_group(user_group_id)
 
     def _cleanup_users(self):
         for user_id in self.user_ids:
             self.fixture.destroy_user(user_id)
 
 
 # TODO: Think about moving this into a pytest-pyro package and make it a
 # pytest plugin
 @pytest.hookimpl(tryfirst=True, hookwrapper=True)
 def pytest_runtest_makereport(item, call):
     """
     Adding the remote traceback if the exception has this information.
 
     VCSServer attaches this information as the attribute `_vcs_server_traceback`
     to the exception instance.
     """
     outcome = yield
     report = outcome.get_result()
     if call.excinfo:
         _add_vcsserver_remote_traceback(report, call.excinfo.value)
 
 
 def _add_vcsserver_remote_traceback(report, exc):
     vcsserver_traceback = getattr(exc, '_vcs_server_traceback', None)
 
     if vcsserver_traceback:
         section = 'VCSServer remote traceback ' + report.when
         report.sections.append((section, vcsserver_traceback))
 
 
 @pytest.fixture(scope='session')
 def testrun():
     return {
         'uuid': uuid.uuid4(),
         'start': datetime.datetime.utcnow().isoformat(),
         'timestamp': int(time.time()),
     }
 
 
 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')
 
 
[e-mail]
[e-mail]()
 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_))
 
 
[e-mail]
[e-mail]()
 def enabled_backends(request):
     backends = request.config.option.backends
     return backends[:]
 
 
[e-mail]
[e-mail]()
 def settings_util(request, db_connection):
     """
     Provides a wired instance of `SettingsUtility` with integrated cleanup.
     """
     utility = SettingsUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class SettingsUtility(object):
     def __init__(self):
         self.rhodecode_ui_ids = []
         self.rhodecode_setting_ids = []
         self.repo_rhodecode_ui_ids = []
         self.repo_rhodecode_setting_ids = []
 
     def create_repo_rhodecode_ui(
             self, repo, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1(
             '{}{}{}'.format(section, value, repo.repo_id)).hexdigest()
 
         setting = RepoRhodeCodeUi()
         setting.repository_id = repo.repo_id
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_rhodecode_ui(
             self, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1('{}{}'.format(section, value)).hexdigest()
 
         setting = RhodeCodeUi()
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_repo_rhodecode_setting(
             self, repo, name, value, type_, cleanup=True):
         setting = RepoRhodeCodeSetting(
             repo.repo_id, key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_setting_ids.append(setting.app_settings_id)
         return setting
 
     def create_rhodecode_setting(self, name, value, type_, cleanup=True):
         setting = RhodeCodeSetting(key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_setting_ids.append(setting.app_settings_id)
 
         return setting
 
     def cleanup(self):
         for id_ in self.rhodecode_ui_ids:
             setting = RhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.rhodecode_setting_ids:
             setting = RhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_ui_ids:
             setting = RepoRhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_setting_ids:
             setting = RepoRhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         Session().commit()
 
 
[e-mail]
[e-mail]()
 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')
 
 
[e-mail]
[e-mail]()
 def rhodecode_fixtures():
     return Fixture()
 
 
[e-mail]
[e-mail]()
 def context_stub():
     """
     Stub context object.
     """
     context = pyramid.testing.DummyResource()
     return context
 
 
[e-mail]
[e-mail]()
 def request_stub():
     """
     Stub request object.
     """
     from rhodecode.lib.base import bootstrap_request
     request = bootstrap_request(scheme='https')
     return request
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 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
 
[e-mail]
[e-mail]()
 def stub_integration_settings():
     return {
         'test_string_field': 'some data',
         'test_int_field': 100,
     }
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 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
 
 
[e-mail]
[e-mail]()
 def local_dt_to_utc():
     def _factory(dt):
         return dt.replace(tzinfo=dateutil.tz.tzlocal()).astimezone(
             dateutil.tz.tzutc()).replace(tzinfo=None)
     return _factory
 
 
[e-mail]
[e-mail]()
 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()
 
 
[e-mail]
[e-mail]()
 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
 
 
 @pytest.fixture(scope="session")
 def tmp_path_factory(request):
     """Return a :class:`_pytest.tmpdir.TempPathFactory` instance for the test session.
     """
 
     class TempPathFactory:
 
         def mktemp(self, basename):
             import tempfile
             return tempfile.mktemp(basename)
 
     return TempPathFactory()

rhodecode/tests/pylons_plugin.py

@@ -1,293 +1,293 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import json
 import platform
 import socket
 
 import pytest
 
 from rhodecode.lib.pyramid_utils import get_app_config
 from rhodecode.tests.fixture import TestINI
 from rhodecode.tests.server_utils import RcVCSServer
 
 
 def _parse_json(value):
     return json.loads(value) if value else None
 
 
 def pytest_addoption(parser):
     parser.addoption(
         '--test-loglevel', dest='test_loglevel',
         help="Set default Logging level for tests, warn (default), info, debug")
     group = parser.getgroup('pylons')
     group.addoption(
         '--with-pylons', dest='pyramid_config',
         help="Set up a Pylons environment with the specified config file.")
     group.addoption(
         '--ini-config-override', action='store', type=_parse_json,
         default=None, dest='pyramid_config_override', help=(
             "Overrides the .ini file settings. Should be specified in JSON"
             " format, e.g. '{\"section\": {\"parameter\": \"value\", ...}}'"
         )
     )
     parser.addini(
         'pyramid_config',
         "Set up a Pyramid environment with the specified config file.")
 
     vcsgroup = parser.getgroup('vcs')
     vcsgroup.addoption(
         '--without-vcsserver', dest='with_vcsserver', action='store_false',
         help="Do not start the VCSServer in a background process.")
     vcsgroup.addoption(
         '--with-vcsserver-http', dest='vcsserver_config_http',
         help="Start the HTTP VCSServer with the specified config file.")
     vcsgroup.addoption(
         '--vcsserver-protocol', dest='vcsserver_protocol',
         help="Start the VCSServer with HTTP protocol support.")
     vcsgroup.addoption(
         '--vcsserver-config-override', action='store', type=_parse_json,
         default=None, dest='vcsserver_config_override', help=(
             "Overrides the .ini file settings for the VCSServer. "
             "Should be specified in JSON "
             "format, e.g. '{\"section\": {\"parameter\": \"value\", ...}}'"
         )
     )
     vcsgroup.addoption(
         '--vcsserver-port', action='store', type=int,
         default=None, help=(
             "Allows to set the port of the vcsserver. Useful when testing "
             "against an already running server and random ports cause "
             "trouble."))
     parser.addini(
         'vcsserver_config_http',
         "Start the HTTP VCSServer with the specified config file.")
     parser.addini(
         'vcsserver_protocol',
         "Start the VCSServer with HTTP protocol support.")
 
 
 @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 is_cygwin():
     return 'cygwin' in platform.system().lower()
 
 
 def _use_log_level(config):
     level = config.getoption('test_loglevel') or 'warn'
     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():
     family = socket.AF_INET
     socktype = socket.SOCK_STREAM
     host = '127.0.0.1'
 
     mysocket = socket.socket(family, socktype)
     mysocket.bind((host, 0))
     port = mysocket.getsockname()[1]
     mysocket.close()
     del mysocket
     return port
 
 
 @pytest.fixture(scope='session')
 def rcserver_port(request):
     port = get_available_port()
     print('Using rcserver port {}'.format(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))
     return port
 
 
 @pytest.fixture(scope='session')
 def available_port_factory():
     """
     Returns a callable which returns free port numbers.
     """
     return get_available_port
 
 
[e-mail]
[e-mail]()
 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/vcs/conftest.py

@@ -1,256 +1,256 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import time
 import shutil
 import datetime
 
 import pytest
 
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.backends.base import Config
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.tests import get_new_dir
 from rhodecode.tests.utils import check_skip_backends, check_xfail_backends
 
 
 @pytest.fixture()
 def vcs_repository_support(
         request, backend_alias, baseapp, _vcs_repo_container):
     """
     Provide a test repository for the test run.
 
     Depending on the value of `recreate_repo_per_test` a new repo for each
     test will be created.
 
     The parameter `--backends` can be used to limit this fixture to specific
     backend implementations.
     """
     cls = request.cls
 
     check_skip_backends(request.node, backend_alias)
     check_xfail_backends(request.node, backend_alias)
 
     if _should_create_repo_per_test(cls):
         _vcs_repo_container = _create_vcs_repo_container(request)
 
     repo = _vcs_repo_container.get_repo(cls, backend_alias=backend_alias)
 
     # TODO: johbo: Supporting old test class api, think about removing this
     cls.repo = repo
     cls.repo_path = repo.path
     cls.default_branch = repo.DEFAULT_BRANCH_NAME
     cls.Backend = cls.backend_class = repo.__class__
     cls.imc = repo.in_memory_commit
 
     return backend_alias, repo
 
 
 @pytest.fixture(scope='class')
 def _vcs_repo_container(request):
     """
     Internal fixture intended to help support class based scoping on demand.
     """
     return _create_vcs_repo_container(request)
 
 
 def _create_vcs_repo_container(request):
     repo_container = VcsRepoContainer()
     if not request.config.getoption('--keep-tmp-path'):
         request.addfinalizer(repo_container.cleanup)
     return repo_container
 
 
 class VcsRepoContainer(object):
 
     def __init__(self):
         self._cleanup_paths = []
         self._repos = {}
 
     def get_repo(self, test_class, backend_alias):
         if backend_alias not in self._repos:
             repo = _create_empty_repository(test_class, backend_alias)
 
             self._cleanup_paths.append(repo.path)
             self._repos[backend_alias] = repo
         return self._repos[backend_alias]
 
     def cleanup(self):
         for repo_path in reversed(self._cleanup_paths):
             shutil.rmtree(repo_path)
 
 
 def _should_create_repo_per_test(cls):
     return getattr(cls, 'recreate_repo_per_test', False)
 
 
 def _create_empty_repository(cls, backend_alias=None):
     Backend = get_backend(backend_alias or cls.backend_alias)
     repo_path = get_new_dir(str(time.time()))
     repo = Backend(repo_path, create=True)
     if hasattr(cls, '_get_commits'):
         commits = cls._get_commits()
         cls.tip = _add_commits_to_repo(repo, commits)
 
     return repo
 
 
[e-mail]
[e-mail]()
 def config():
     """
     Instance of a repository config.
 
     The instance contains only one value:
 
     - Section: "section-a"
     - Key:     "a-1"
     - Value:   "value-a-1"
 
     The intended usage is for cases where a config instance is needed but no
     specific content is required.
     """
     config = Config()
     config.set('section-a', 'a-1', 'value-a-1')
     return config
 
 
 def _add_commits_to_repo(repo, commits):
     imc = repo.in_memory_commit
     tip = None
 
     for commit in commits:
         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))
 
         tip = imc.commit(
             message=unicode(commit['message']),
             author=unicode(commit['author']),
             date=commit['date'],
             branch=commit.get('branch'))
     return tip
 
 
[e-mail]
[e-mail]()
 def vcs_repo(request, backend_alias):
     Backend = get_backend(backend_alias)
     repo_path = get_new_dir(str(time.time()))
     repo = Backend(repo_path, create=True)
 
     @request.addfinalizer
     def cleanup():
         shutil.rmtree(repo_path)
 
     return repo
 
 
[e-mail]
[e-mail]()
 def generate_repo_with_commits(vcs_repo):
     """
     Creates a fabric to generate N comits with some file nodes on a randomly
     generated repository
     """
 
     def commit_generator(num):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in xrange(num):
             yield {
                 'message': 'Commit %d' % x,
                 'author': 'Joe Doe <[e-mail]>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode('file_%d.txt' % x, content='Foobar %d' % x),
                 ],
                 'modified': [
                     FileNode('file_%d.txt' % x,
                              content='Foobar %d modified' % (x-1)),
                 ]
             }
 
     def commit_maker(num=5):
         _add_commits_to_repo(vcs_repo, commit_generator(num))
         return vcs_repo
 
     return commit_maker
 
 
[e-mail]
[e-mail]()
 def hg_repo(request, vcs_repo):
     repo = vcs_repo
 
     commits = repo._get_commits()
     _add_commits_to_repo(repo, commits)
 
     return repo
 
 
[e-mail]
[e-mail]()
 def hg_commit(hg_repo):
     return hg_repo.get_commit()
 
 
 class BackendTestMixin(object):
     """
     This is a backend independent test case class which should be created
     with ``type`` method.
 
     It is required to set following attributes at subclass:
 
     - ``backend_alias``: alias of used backend (see ``vcs.BACKENDS``)
     - ``repo_path``: path to the repository which would be created for set of
       tests
     - ``recreate_repo_per_test``: If set to ``False``, repo would NOT be
       created
       before every single test. Defaults to ``True``.
     """
     recreate_repo_per_test = True
 
     @classmethod
     def _get_commits(cls):
         commits = [
             {
                 'message': u'Initial commit',
                 'author': u'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('foobar', content='Foobar'),
                     FileNode('foobar2', content='Foobar II'),
                     FileNode('foo/bar/baz', content='baz here!'),
                 ],
             },
             {
                 'message': u'Changes...',
                 'author': u'Jane Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 21),
                 'added': [
                     FileNode('some/new.txt', content='news...'),
                 ],
                 'changed': [
                     FileNode('foobar', 'Foobar I'),
                 ],
                 'removed': [],
             },
         ]
         return commits
 
 

rhodecode/tests/vcs/test_archives.py

@@ -1,151 +1,151 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import datetime
 import os
 import shutil
 import tarfile
 import tempfile
 import zipfile
 import StringIO
 
 import mock
 import pytest
 
 from rhodecode.lib.vcs.backends import base
 from rhodecode.lib.vcs.exceptions import ImproperArchiveTypeError, VCSError
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.tests.vcs.conftest import BackendTestMixin
 
 
 @pytest.mark.usefixtures("vcs_repository_support")
 class TestArchives(BackendTestMixin):
 
     @pytest.fixture(autouse=True)
     def tempfile(self, request):
         self.temp_file = tempfile.mkstemp()[1]
 
         @request.addfinalizer
         def cleanup():
             os.remove(self.temp_file)
 
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in range(5):
             yield {
                 'message': 'Commit %d' % x,
                 'author': 'Joe Doe <[e-mail]>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode(
                         '%d/file_%d.txt' % (x, x), content='Foobar %d' % x),
                 ],
             }
 
     @pytest.mark.parametrize('compressor', ['gz', 'bz2'])
     def test_archive_tar(self, compressor):
         self.tip.archive_repo(
             self.temp_file, kind='t' + compressor, prefix='repo')
         out_dir = tempfile.mkdtemp()
         out_file = tarfile.open(self.temp_file, 'r|' + compressor)
         out_file.extractall(out_dir)
         out_file.close()
 
         for x in range(5):
             node_path = '%d/file_%d.txt' % (x, x)
             with open(os.path.join(out_dir, 'repo/' + node_path)) as f:
                 file_content = f.read()
             assert file_content == self.tip.get_node(node_path).content
 
         shutil.rmtree(out_dir)
 
     def test_archive_zip(self):
         self.tip.archive_repo(self.temp_file, kind='zip', prefix='repo')
         out = zipfile.ZipFile(self.temp_file)
 
         for x in range(5):
             node_path = '%d/file_%d.txt' % (x, x)
             decompressed = StringIO.StringIO()
             decompressed.write(out.read('repo/' + node_path))
             assert decompressed.getvalue() == \
                 self.tip.get_node(node_path).content
             decompressed.close()
 
     def test_archive_zip_with_metadata(self):
         self.tip.archive_repo(self.temp_file, kind='zip',
                               prefix='repo', write_metadata=True)
 
         out = zipfile.ZipFile(self.temp_file)
         metafile = out.read('.archival.txt')
 
         raw_id = self.tip.raw_id
         assert 'commit_id:%s' % raw_id in metafile
 
         for x in range(5):
             node_path = '%d/file_%d.txt' % (x, x)
             decompressed = StringIO.StringIO()
             decompressed.write(out.read('repo/' + node_path))
             assert decompressed.getvalue() == \
                 self.tip.get_node(node_path).content
             decompressed.close()
 
     def test_archive_wrong_kind(self):
         with pytest.raises(ImproperArchiveTypeError):
             self.tip.archive_repo(self.temp_file, kind='wrong kind')
 
 
[e-mail]
[e-mail]()
 def base_commit():
     """
     Prepare a `base.BaseCommit` just enough for `_validate_archive_prefix`.
     """
     commit = base.BaseCommit()
     commit.repository = mock.Mock()
     commit.repository.name = u'fake_repo'
     commit.short_id = 'fake_id'
     return commit
 
 
 @pytest.mark.parametrize("prefix", [u"unicode-prefix", u"Ünïcödë"])
 def test_validate_archive_prefix_enforces_bytes_as_prefix(prefix, base_commit):
     with pytest.raises(ValueError):
         base_commit._validate_archive_prefix(prefix)
 
 
 def test_validate_archive_prefix_empty_prefix(base_commit):
     # TODO: johbo: Should raise a ValueError here.
     with pytest.raises(VCSError):
         base_commit._validate_archive_prefix('')
 
 
 def test_validate_archive_prefix_with_leading_slash(base_commit):
     # TODO: johbo: Should raise a ValueError here.
     with pytest.raises(VCSError):
         base_commit._validate_archive_prefix('/any')
 
 
 def test_validate_archive_prefix_falls_back_to_repository_name(base_commit):
     prefix = base_commit._validate_archive_prefix(None)
     expected_prefix = base_commit._ARCHIVE_PREFIX_TEMPLATE.format(
         repo_name='fake_repo',
         short_id='fake_id')
     assert isinstance(prefix, str)
     assert prefix == expected_prefix

rhodecode/tests/vcs/test_client_http.py

@@ -1,133 +1,133 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 
 import mock
 import msgpack
 import pytest
 
 from rhodecode.lib import vcs
 from rhodecode.lib.vcs import client_http, exceptions
 
 
 def is_new_connection(logger, level, message):
     return (
         logger == 'requests.packages.urllib3.connectionpool' and
         message.startswith('Starting new HTTP'))
 
 
[e-mail]
[e-mail]()
 def stub_session():
     """
     Stub of `requests.Session()`.
     """
     session = mock.Mock()
     post = session.post()
     post.content = msgpack.packb({})
     post.status_code = 200
 
     session.reset_mock()
     return session
 
 
[e-mail]
[e-mail]()
 def stub_fail_session():
     """
     Stub of `requests.Session()`.
     """
     session = mock.Mock()
     post = session.post()
     post.content = msgpack.packb({'error': '500'})
     post.status_code = 500
 
     session.reset_mock()
     return session
 
 
[e-mail]
[e-mail]()
 def stub_session_factory(stub_session):
     """
     Stub of `rhodecode.lib.vcs.client_http.ThreadlocalSessionFactory`.
     """
     session_factory = mock.Mock()
     session_factory.return_value = stub_session
     return session_factory
 
 
[e-mail]
[e-mail]()
 def stub_session_failing_factory(stub_fail_session):
     """
     Stub of `rhodecode.lib.vcs.client_http.ThreadlocalSessionFactory`.
     """
     session_factory = mock.Mock()
     session_factory.return_value = stub_fail_session
     return session_factory
 
 
 def test_uses_persistent_http_connections(caplog, vcsbackend_hg):
     repo = vcsbackend_hg.repo
     remote_call = repo._remote.branches
 
     with caplog.at_level(logging.INFO):
         for x in range(5):
             remote_call(normal=True, closed=False)
 
     new_connections = [
         r for r in caplog.record_tuples if is_new_connection(*r)]
     assert len(new_connections) <= 1
 
 
 def test_repo_maker_uses_session_for_classmethods(stub_session_factory):
     repo_maker = client_http.RemoteVCSMaker(
         'server_and_port', 'endpoint', 'test_dummy_scm', stub_session_factory)
     repo_maker.example_call()
     stub_session_factory().post.assert_called_with(
         'http://server_and_port/endpoint', data=mock.ANY)
 
 
 def test_repo_maker_uses_session_for_instance_methods(
         stub_session_factory, config):
     repo_maker = client_http.RemoteVCSMaker(
         'server_and_port', 'endpoint', 'test_dummy_scm', stub_session_factory)
     repo = repo_maker('stub_path', 'stub_repo_id', config)
     repo.example_call()
     stub_session_factory().post.assert_called_with(
         'http://server_and_port/endpoint', data=mock.ANY)
 
 
 @mock.patch('rhodecode.lib.vcs.client_http.ThreadlocalSessionFactory')
 @mock.patch('rhodecode.lib.vcs.connection')
 def test_connect_passes_in_the_same_session(
         connection, session_factory_class, stub_session):
     session_factory = session_factory_class.return_value
     session_factory.return_value = stub_session
 
     vcs.connect_http('server_and_port')
 
 
 def test_repo_maker_uses_session_that_throws_error(
         stub_session_failing_factory, config):
     repo_maker = client_http.RemoteVCSMaker(
         'server_and_port', 'endpoint', 'test_dummy_scm', stub_session_failing_factory)
     repo = repo_maker('stub_path', 'stub_repo_id', config)
 
     with pytest.raises(exceptions.HttpVCSCommunicationError):
         repo.example_call()

rhodecode/tests/vcs/test_hg.py

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

rhodecode/tests/vcs/test_inmemory.py

@@ -1,349 +1,349 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Tests so called "in memory commits" commit API of vcs.
 """
 import datetime
 
 import pytest
 
 from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.lib.vcs.exceptions import (
     EmptyRepositoryError, NodeAlreadyAddedError, NodeAlreadyExistsError,
     NodeAlreadyRemovedError, NodeAlreadyChangedError, NodeDoesNotExistError,
     NodeNotChangedError)
 from rhodecode.lib.vcs.nodes import DirNode, FileNode
 from rhodecode.tests.vcs.conftest import BackendTestMixin
 
 
[e-mail]
[e-mail]()
 def nodes():
     nodes = [
         FileNode('foobar', content='Foo & bar'),
         FileNode('foobar2', content='Foo & bar, doubled!'),
         FileNode('foo bar with spaces', content=''),
         FileNode('foo/bar/baz', content='Inside'),
         FileNode(
             'foo/bar/file.bin',
             content=(
                 '\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1\x00\x00\x00\x00\x00\x00'
                 '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00;\x00\x03\x00\xfe'
                 '\xff\t\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
                 '\x01\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00'
                 '\x00\x18\x00\x00\x00\x01\x00\x00\x00\xfe\xff\xff\xff\x00\x00'
                 '\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff'
                 '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
             )
         ),
     ]
     return nodes
 
 
 @pytest.mark.usefixtures("vcs_repository_support")
 class TestInMemoryCommit(BackendTestMixin):
     """
     This is a backend independent test case class which should be created
     with ``type`` method.
 
     It is required to set following attributes at subclass:
 
     - ``backend_alias``: alias of used backend (see ``vcs.BACKENDS``)
     """
 
     @classmethod
     def _get_commits(cls):
         return []
 
     def test_add(self, nodes):
         for node in nodes:
             self.imc.add(node)
 
         self.commit()
         self.assert_succesful_commit(nodes)
 
     @pytest.mark.backends("hg")
     def test_add_on_branch_hg(self, nodes):
         for node in nodes:
             self.imc.add(node)
         self.commit(branch=u'stable')
         self.assert_succesful_commit(nodes)
 
     @pytest.mark.backends("git")
     def test_add_on_branch_git(self, nodes):
         for node in nodes:
             self.imc.add(node)
         self.commit(branch=u'stable')
         self.assert_succesful_commit(nodes)
 
     def test_add_in_bulk(self, nodes):
         self.imc.add(*nodes)
 
         self.commit()
         self.assert_succesful_commit(nodes)
 
     def test_add_non_ascii_files(self):
         nodes = [
             FileNode('żółwik/zwierzątko_utf8_str', content='ćććć'),
             FileNode(u'żółwik/zwierzątko_unicode', content=u'ćććć'),
         ]
 
         for node in nodes:
             self.imc.add(node)
 
         self.commit()
         self.assert_succesful_commit(nodes)
 
     def commit(self, branch=None):
         self.old_commit_count = len(self.repo.commit_ids)
         self.commit_message = u'Test commit with unicode: żółwik'
         self.commit_author = u'{} <[e-mail]>'.format(self.__class__.__name__)
         self.commit = self.imc.commit(
             message=self.commit_message, author=self.commit_author,
             branch=branch)
 
     def test_add_actually_adds_all_nodes_at_second_commit_too(self):
         to_add = [
             FileNode('foo/bar/image.png', content='\0'),
             FileNode('foo/README.txt', content='readme!'),
         ]
         self.imc.add(*to_add)
         commit = self.imc.commit(u'Initial', u'joe doe <[e-mail]>')
         assert isinstance(commit.get_node('foo'), DirNode)
         assert isinstance(commit.get_node('foo/bar'), DirNode)
         self.assert_nodes_in_commit(commit, to_add)
 
         # commit some more files again
         to_add = [
             FileNode('foo/bar/foobaz/bar', content='foo'),
             FileNode('foo/bar/another/bar', content='foo'),
             FileNode('foo/baz.txt', content='foo'),
             FileNode('foobar/foobaz/file', content='foo'),
             FileNode('foobar/barbaz', content='foo'),
         ]
         self.imc.add(*to_add)
         commit = self.imc.commit(u'Another', u'joe doe <[e-mail]>')
         self.assert_nodes_in_commit(commit, to_add)
 
     def test_add_raise_already_added(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         with pytest.raises(NodeAlreadyAddedError):
             self.imc.add(node)
 
     def test_check_integrity_raise_already_exist(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         self.imc.commit(message=u'Added foobar', author=u'{} <[e-mail]>'.format(self))
         self.imc.add(node)
         with pytest.raises(NodeAlreadyExistsError):
             self.imc.commit(message='new message', author=u'{} <[e-mail]>'.format(self))
 
     def test_change(self):
         self.imc.add(FileNode('foo/bar/baz', content='foo'))
         self.imc.add(FileNode('foo/fbar', content='foobar'))
         tip = self.imc.commit(u'Initial', u'joe doe <[e-mail]>')
 
         # Change node's content
         node = FileNode('foo/bar/baz', content='My **changed** content')
         self.imc.change(node)
         self.imc.commit(u'Changed %s' % node.path, u'joe doe <[e-mail]>')
 
         newtip = self.repo.get_commit()
         assert tip != newtip
         assert tip.id != newtip.id
         self.assert_nodes_in_commit(newtip, (node,))
 
     def test_change_non_ascii(self):
         to_add = [
             FileNode('żółwik/zwierzątko', content='ćććć'),
             FileNode(u'żółwik/zwierzątko_uni', content=u'ćććć'),
         ]
         for node in to_add:
             self.imc.add(node)
 
         tip = self.imc.commit(u'Initial', u'joe doe <[e-mail]>')
 
         # Change node's content
         node = FileNode('żółwik/zwierzątko', content='My **changed** content')
         self.imc.change(node)
         self.imc.commit(u'Changed %s' % safe_unicode(node.path),
                         author=u'joe doe <[e-mail]>')
 
         node_uni = FileNode(
             u'żółwik/zwierzątko_uni', content=u'My **changed** content')
         self.imc.change(node_uni)
         self.imc.commit(u'Changed %s' % safe_unicode(node_uni.path),
                         author=u'joe doe <[e-mail]>')
 
         newtip = self.repo.get_commit()
         assert tip != newtip
         assert tip.id != newtip.id
 
         self.assert_nodes_in_commit(newtip, (node, node_uni))
 
     def test_change_raise_empty_repository(self):
         node = FileNode('foobar')
         with pytest.raises(EmptyRepositoryError):
             self.imc.change(node)
 
     def test_check_integrity_change_raise_node_does_not_exist(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         self.imc.commit(message=u'Added foobar', author=u'{} <[e-mail]>'.format(self))
         node = FileNode('not-foobar', content='')
         self.imc.change(node)
         with pytest.raises(NodeDoesNotExistError):
             self.imc.commit(message='Changed not existing node', author=u'{} <[e-mail]>'.format(self))
 
     def test_change_raise_node_already_changed(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         self.imc.commit(message=u'Added foobar', author=u'{} <[e-mail]>'.format(self))
         node = FileNode('foobar', content='more baz')
         self.imc.change(node)
         with pytest.raises(NodeAlreadyChangedError):
             self.imc.change(node)
 
     def test_check_integrity_change_raise_node_not_changed(self, nodes):
         self.test_add(nodes)  # Performs first commit
 
         node = FileNode(nodes[0].path, content=nodes[0].content)
         self.imc.change(node)
         with pytest.raises(NodeNotChangedError):
             self.imc.commit(
                 message=u'Trying to mark node as changed without touching it',
                 author=u'{} <[e-mail]>'.format(self))
 
     def test_change_raise_node_already_removed(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         self.imc.commit(message=u'Added foobar', author=u'{} <[e-mail]>'.format(self))
         self.imc.remove(FileNode('foobar'))
         with pytest.raises(NodeAlreadyRemovedError):
             self.imc.change(node)
 
     def test_remove(self, nodes):
         self.test_add(nodes)  # Performs first commit
 
         tip = self.repo.get_commit()
         node = nodes[0]
         assert node.content == tip.get_node(node.path).content
         self.imc.remove(node)
         self.imc.commit(
             message=u'Removed %s' % node.path, author=u'{} <[e-mail]>'.format(self))
 
         newtip = self.repo.get_commit()
         assert tip != newtip
         assert tip.id != newtip.id
         with pytest.raises(NodeDoesNotExistError):
             newtip.get_node(node.path)
 
     def test_remove_last_file_from_directory(self):
         node = FileNode('omg/qwe/foo/bar', content='foobar')
         self.imc.add(node)
         self.imc.commit(u'added', author=u'joe doe <[e-mail]>')
 
         self.imc.remove(node)
         tip = self.imc.commit(u'removed', u'joe doe <[e-mail]>')
         with pytest.raises(NodeDoesNotExistError):
             tip.get_node('omg/qwe/foo/bar')
 
     def test_remove_raise_node_does_not_exist(self, nodes):
         self.imc.remove(nodes[0])
         with pytest.raises(NodeDoesNotExistError):
             self.imc.commit(
                 message='Trying to remove node at empty repository',
                 author=u'{} <[e-mail]>'.format(self))
 
     def test_check_integrity_remove_raise_node_does_not_exist(self, nodes):
         self.test_add(nodes)  # Performs first commit
 
         node = FileNode('no-such-file')
         self.imc.remove(node)
         with pytest.raises(NodeDoesNotExistError):
             self.imc.commit(
                 message=u'Trying to remove not existing node',
                 author=u'{} <[e-mail]>'.format(self))
 
     def test_remove_raise_node_already_removed(self, nodes):
         self.test_add(nodes)  # Performs first commit
 
         node = FileNode(nodes[0].path)
         self.imc.remove(node)
         with pytest.raises(NodeAlreadyRemovedError):
             self.imc.remove(node)
 
     def test_remove_raise_node_already_changed(self, nodes):
         self.test_add(nodes)  # Performs first commit
 
         node = FileNode(nodes[0].path, content='Bending time')
         self.imc.change(node)
         with pytest.raises(NodeAlreadyChangedError):
             self.imc.remove(node)
 
     def test_reset(self):
         self.imc.add(FileNode('foo', content='bar'))
         # self.imc.change(FileNode('baz', content='new'))
         # self.imc.remove(FileNode('qwe'))
         self.imc.reset()
         assert not any((self.imc.added, self.imc.changed, self.imc.removed))
 
     def test_multiple_commits(self):
         N = 3  # number of commits to perform
         last = None
         for x in xrange(N):
             fname = 'file%s' % str(x).rjust(5, '0')
             content = 'foobar\n' * x
             node = FileNode(fname, content=content)
             self.imc.add(node)
             commit = self.imc.commit(u"Commit no. %s" % (x + 1), author=u'vcs <[e-mail]>')
             assert last != commit
             last = commit
 
         # Check commit number for same repo
         assert len(self.repo.commit_ids) == N
 
         # Check commit number for recreated repo
         repo = self.Backend(self.repo_path)
         assert len(repo.commit_ids) == N
 
     def test_date_attr(self, local_dt_to_utc):
         node = FileNode('foobar.txt', content='Foobared!')
         self.imc.add(node)
         date = datetime.datetime(1985, 1, 30, 1, 45)
         commit = self.imc.commit(
             u"Committed at time when I was born ;-)",
             author=u'{} <[e-mail]>'.format(self), date=date)
 
         assert commit.date == local_dt_to_utc(date)
 
     def assert_succesful_commit(self, added_nodes):
         newtip = self.repo.get_commit()
         assert self.commit == newtip
         assert self.old_commit_count + 1 == len(self.repo.commit_ids)
         assert newtip.message == self.commit_message
         assert newtip.author == self.commit_author
         assert not any((self.imc.added, self.imc.changed, self.imc.removed))
         self.assert_nodes_in_commit(newtip, added_nodes)
 
     def assert_nodes_in_commit(self, commit, nodes):
         for node in nodes:
             assert commit.get_node(node.path).content == node.content

rhodecode/tests/vcs/test_svn.py

@@ -1,186 +1,186 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 
 import mock
 import pytest
 
 from rhodecode.tests import SVN_REPO, TEST_DIR, TESTS_TMP_PATH
 from rhodecode.lib.vcs.backends.svn.repository import SubversionRepository
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import VCSError
 
 
 pytestmark = [
     pytest.mark.backends("svn"),
     pytest.mark.usefixtures("baseapp"),
 ]
 
 
[e-mail]
[e-mail]()
 def repo(baseapp):
     repo = SubversionRepository(os.path.join(TESTS_TMP_PATH, SVN_REPO))
     return repo
 
 
[e-mail]
[e-mail]()
 def head(repo):
     return repo.get_commit()
 
 
 def test_init_fails_if_path_does_not_exist():
     path = os.path.join(TEST_DIR, 'i-do-not-exist')
     with pytest.raises(VCSError):
         SubversionRepository(path)
 
 
 def test_init_fails_if_path_is_not_a_valid_repository(tmpdir):
     path = unicode(tmpdir.mkdir(u'unicode ä'))
     with pytest.raises(VCSError):
         SubversionRepository(path)
 
 
 def test_repo_clone(vcsbackend, reposerver):
     source = vcsbackend.create_repo(number_of_commits=3)
     reposerver.serve(source)
     repo = SubversionRepository(
         vcsbackend.new_repo_path(),
         create=True,
         src_url=reposerver.url)
 
     assert source.commit_ids == repo.commit_ids
     assert source[0].message == repo[0].message
 
 
 def test_latest_commit(head):
     assert head.raw_id == '393'
 
 
 def test_commit_description(head):
     assert head.message == """Added a symlink"""
 
 
 def test_commit_author(head):
     assert head.author == 'marcin'
 
 
 @pytest.mark.parametrize("filename, content, mime_type", [
     ('test.txt', 'Text content\n', None),
     ('test.bin', '\0 binary \0', 'application/octet-stream'),
 ], ids=['text', 'binary'])
 def test_sets_mime_type_correctly(vcsbackend, filename, content, mime_type):
     repo = vcsbackend.create_repo()
     vcsbackend.ensure_file(filename, content)
     file_properties = repo._remote.node_properties(filename, 1)
     assert file_properties.get('svn:mime-type') == mime_type
 
 
 def test_slice_access(repo):
     page_size = 5
     page = 0
     start = page * page_size
     end = start + page_size - 1
 
     commits = list(repo[start:end])
     assert [commit.raw_id for commit in commits] == ['1', '2', '3', '4']
 
 
 def test_walk_changelog_page(repo):
     page_size = 5
     page = 0
     start = page * page_size
     end = start + page_size - 1
 
     commits = list(repo[start:end])
     changelog = [
         'r%s, %s, %s' % (c.raw_id, c.author, c.message) for c in commits]
 
     expexted_messages = [
         'r1, marcin, initial import',
         'r2, marcin, hg ignore',
         'r3, marcin, Pip standards refactor',
         'r4, marcin, Base repository few new functions added']
     assert changelog == expexted_messages
 
 
 def test_read_full_file_tree(head):
     for topnode, dirs, files in head.walk():
         for f in files:
             len(f.content)
 
 
 def test_topnode_files_attribute(head):
     topnode = head.get_node('')
     topnode.files
 
 
 @pytest.mark.parametrize("filename, content, branch, mime_type", [
     (u'branches/plain/test.txt', 'Text content\n', 'plain', None),
     (u'branches/uniçö∂e/test.bin', '\0 binary \0', u'uniçö∂e',
         'application/octet-stream'),
 ], ids=['text', 'binary'])
 def test_unicode_refs(vcsbackend, filename, content, branch, mime_type):
     repo = vcsbackend.create_repo()
     vcsbackend.ensure_file(filename, content)
     with mock.patch(("rhodecode.lib.vcs.backends.svn.repository"
                     ".SubversionRepository._patterns_from_section"),
                     return_value=['branches/*']):
         assert u'branches/{0}'.format(branch) in repo.branches
 
 
 def test_compatible_version(monkeypatch, vcsbackend):
     monkeypatch.setattr(settings, 'SVN_COMPATIBLE_VERSION', 'pre-1.8-compatible')
     path = vcsbackend.new_repo_path()
     SubversionRepository(path, create=True)
     with open('{}/db/format'.format(path)) as f:
         first_line = f.readline().strip()
         assert first_line == '4'
 
 
 def test_invalid_compatible_version(monkeypatch, vcsbackend):
     monkeypatch.setattr(settings, 'SVN_COMPATIBLE_VERSION', 'i-am-an-invalid-setting')
     path = vcsbackend.new_repo_path()
     with pytest.raises(Exception):
         SubversionRepository(path, create=True)
 
 
 class TestSVNCommit(object):
 
     @pytest.fixture(autouse=True)
     def prepare(self, repo):
         self.repo = repo
 
     def test_file_history_from_commits(self):
         node = self.repo[10].get_node('setup.py')
         commit_ids = [commit.raw_id for commit in node.history]
         assert ['8'] == commit_ids
 
         node = self.repo[20].get_node('setup.py')
         node_ids = [commit.raw_id for commit in node.history]
         assert ['18',
                 '8'] == node_ids
 
         # special case we check history from commit that has this particular
         # file changed this means we check if it's included as well
         node = self.repo.get_commit('18').get_node('setup.py')
         node_ids = [commit.raw_id for commit in node.history]
         assert ['18',
                 '8'] == node_ids

rhodecode/tests/vcs_operations/conftest.py

@@ -1,341 +1,341 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 py.test config 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.
 """
 
 import os
 import tempfile
 import textwrap
 import pytest
 
 from rhodecode import events
 from rhodecode.model.db import Integration, UserRepoToPerm, Permission, \
     UserToRepoBranchPermission, User
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.model.db import Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel
 from rhodecode.integrations.types.webhook import WebhookIntegrationType
 
 from rhodecode.tests import GIT_REPO, HG_REPO
 from rhodecode.tests.fixture import Fixture
 from rhodecode.tests.server_utils import RcWebServer
 
 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)
 
 
 @pytest.fixture(scope="module")
 def rcextensions(request, db_connection, tmpdir_factory):
     """
     Installs a testing rcextensions pack to ensure they work as expected.
     """
     init_content = textwrap.dedent("""
         # Forward import the example rcextensions to make it
         # active for our tests.
         from rhodecode.tests.other.example_rcextensions import *
     """)
 
     # Note: rcextensions are looked up based on the path of the ini file
     root_path = tmpdir_factory.getbasetemp()
     rcextensions_path = root_path.join('rcextensions')
     init_path = rcextensions_path.join('__init__.py')
 
     if rcextensions_path.check():
         pytest.fail(
             "Path for rcextensions already exists, please clean up before "
             "test run this path: %s" % (rcextensions_path, ))
         return
 
     request.addfinalizer(rcextensions_path.remove)
     init_path.write_binary(init_content, ensure=True)
 
 
 @pytest.fixture(scope="module")
 def repos(request, db_connection):
     """Create a copy of each test repo in a repo group."""
     fixture = Fixture()
     repo_group = fixture.create_repo_group(REPO_GROUP)
     repo_group_id = repo_group.group_id
     fixture.create_fork(HG_REPO, HG_REPO,
                         repo_name_full=HG_REPO_WITH_GROUP,
                         repo_group=repo_group_id)
     fixture.create_fork(GIT_REPO, GIT_REPO,
                         repo_name_full=GIT_REPO_WITH_GROUP,
                         repo_group=repo_group_id)
 
     @request.addfinalizer
     def cleanup():
         fixture.destroy_repo(HG_REPO_WITH_GROUP)
         fixture.destroy_repo(GIT_REPO_WITH_GROUP)
         fixture.destroy_repo_group(repo_group_id)
 
 
 @pytest.fixture(scope="module")
 def rc_web_server_config_modification():
     return []
 
 
 @pytest.fixture(scope="module")
 def rc_web_server_config_factory(testini_factory, rc_web_server_config_modification):
     """
     Configuration file used for the fixture `rc_web_server`.
     """
 
     def factory(rcweb_port, vcsserver_port):
         custom_params = [
             {'handler_console': {'level': 'DEBUG'}},
             {'server:main': {'port': rcweb_port}},
             {'app:main': {'vcs.server': 'localhost:%s' % vcsserver_port}}
         ]
         custom_params.extend(rc_web_server_config_modification)
         return testini_factory(custom_params)
     return factory
 
 
 @pytest.fixture(scope="module")
 def rc_web_server(
         request, vcsserver_factory, available_port_factory,
         rc_web_server_config_factory, repos, rcextensions):
     """
     Run the web server as a subprocess. with it's own instance of vcsserver
     """
     rcweb_port = available_port_factory()
     print('Using rcweb ops test port {}'.format(rcweb_port))
 
     vcsserver_port = available_port_factory()
     print('Using vcsserver ops test port {}'.format(vcsserver_port))
 
     vcs_log = os.path.join(tempfile.gettempdir(), 'rc_op_vcs.log')
     vcsserver_factory(
             request, vcsserver_port=vcsserver_port,
             log_file=vcs_log,
             overrides=(
                 {'server:main': {'workers': 2}},
                 {'server:main': {'graceful_timeout': 10}},
             ))
 
     rc_log = os.path.join(tempfile.gettempdir(), 'rc_op_web.log')
     rc_web_server_config = rc_web_server_config_factory(
         rcweb_port=rcweb_port,
         vcsserver_port=vcsserver_port)
     server = RcWebServer(rc_web_server_config, log_file=rc_log)
     server.start()
 
     @request.addfinalizer
     def cleanup():
         server.shutdown()
 
     server.wait_until_ready()
     return server
 
 
[e-mail]
[e-mail]()
 def disable_locking(baseapp):
     r = Repository.get_by_repo_name(GIT_REPO)
     Repository.unlock(r)
     r.enable_locking = False
     Session().add(r)
     Session().commit()
 
     r = Repository.get_by_repo_name(HG_REPO)
     Repository.unlock(r)
     r.enable_locking = False
     Session().add(r)
     Session().commit()
 
 
[e-mail]
[e-mail]()
 def enable_auth_plugins(request, baseapp, csrf_token):
     """
     Return a factory object that when called, allows to control which
     authentication plugins are enabled.
     """
     def _enable_plugins(plugins_list, override=None):
         override = override or {}
         params = {
             'auth_plugins': ','.join(plugins_list),
         }
 
         # helper translate some names to others
         name_map = {
             'token': 'authtoken'
         }
 
         for module in plugins_list:
             plugin_name = module.partition('#')[-1]
             if plugin_name in name_map:
                 plugin_name = name_map[plugin_name]
             enabled_plugin = 'auth_%s_enabled' % plugin_name
             cache_ttl = 'auth_%s_cache_ttl' % plugin_name
 
             # default params that are needed for each plugin,
             # `enabled` and `cache_ttl`
             params.update({
                 enabled_plugin: True,
                 cache_ttl: 0
             })
             if override.get:
                 params.update(override.get(module, {}))
 
             validated_params = params
             for k, v in validated_params.items():
                 setting = SettingsModel().create_or_update_setting(k, v)
                 Session().add(setting)
             Session().commit()
 
     def cleanup():
         _enable_plugins(['egg:rhodecode-enterprise-ce#rhodecode'])
 
     request.addfinalizer(cleanup)
 
     return _enable_plugins
 
 
[e-mail]
[e-mail]()
 def fs_repo_only(request, rhodecode_fixtures):
     def fs_repo_fabric(repo_name, repo_type):
         rhodecode_fixtures.create_repo(repo_name, repo_type=repo_type)
         rhodecode_fixtures.destroy_repo(repo_name, fs_remove=False)
 
         def cleanup():
             rhodecode_fixtures.destroy_repo(repo_name, fs_remove=True)
             rhodecode_fixtures.destroy_repo_on_filesystem(repo_name)
 
         request.addfinalizer(cleanup)
 
     return fs_repo_fabric
 
 
[e-mail]
[e-mail]()
 def enable_webhook_push_integration(request):
     integration = Integration()
     integration.integration_type = WebhookIntegrationType.key
     Session().add(integration)
 
     settings = dict(
         url='http://httpbin.org/post',
         secret_token='secret',
         username=None,
         password=None,
         custom_header_key=None,
         custom_header_val=None,
         method_type='post',
         events=[events.RepoPushEvent.name],
         log_data=True
     )
 
     IntegrationModel().update_integration(
         integration,
         name='IntegrationWebhookTest',
         enabled=True,
         settings=settings,
         repo=None,
         repo_group=None,
         child_repos_only=False,
     )
     Session().commit()
     integration_id = integration.integration_id
 
     @request.addfinalizer
     def cleanup():
         integration = Integration.get(integration_id)
         Session().delete(integration)
         Session().commit()
 
 
[e-mail]
[e-mail]()
 def branch_permission_setter(request):
     """
 
     def my_test(branch_permission_setter)
         branch_permission_setter(repo_name, username, pattern='*', permission='branch.push')
 
     """
 
     rule_id = None
     write_perm_id = None
 
     def _branch_permissions_setter(
             repo_name, username, pattern='*', permission='branch.push_force'):
         global rule_id, write_perm_id
 
         repo = Repository.get_by_repo_name(repo_name)
         repo_id = repo.repo_id
 
         user = User.get_by_username(username)
         user_id = user.user_id
 
         rule_perm_obj = Permission.get_by_key(permission)
 
         write_perm = None
 
         # add new entry, based on existing perm entry
         perm = UserRepoToPerm.query() \
             .filter(UserRepoToPerm.repository_id == repo_id) \
             .filter(UserRepoToPerm.user_id == user_id) \
             .first()
 
         if not perm:
             # such user isn't defined in Permissions for repository
             # we now on-the-fly add new permission
 
             write_perm = UserRepoToPerm()
             write_perm.permission = Permission.get_by_key('repository.write')
             write_perm.repository_id = repo_id
             write_perm.user_id = user_id
             Session().add(write_perm)
             Session().flush()
 
             perm = write_perm
 
         rule = UserToRepoBranchPermission()
         rule.rule_to_perm_id = perm.repo_to_perm_id
         rule.branch_pattern = pattern
         rule.rule_order = 10
         rule.permission = rule_perm_obj
         rule.repository_id = repo_id
         Session().add(rule)
         Session().commit()
 
         global rule, write_perm
 
         return rule
 
     @request.addfinalizer
     def cleanup():
         if rule:
             Session().delete(rule)
             Session().commit()
         if write_perm:
             Session().delete(write_perm)
             Session().commit()
 
     return _branch_permissions_setter