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 error_handler(exception, request): # TODO: dan: replace the old pylons error controller with this from rhodecode.model.settings import SettingsModel from rhodecode.lib.utils2 import AttributeDict try: rc_config = SettingsModel().get_all_settings() except Exception: log.exception('failed to fetch settings') rc_config = {} base_response = HTTPInternalServerError() # prefer original exception for the response since it may have headers set if isinstance(exception, HTTPError): base_response = exception c = AttributeDict() c.error_message = base_response.status c.error_explanation = base_response.explanation or str(base_response) c.visual = AttributeDict() c.visual.rhodecode_support_url = ( request.registry.settings.get('rhodecode_support_url') or request.route_url('rhodecode_support')) c.redirect_time = 0 c.rhodecode_name = rc_config.get('rhodecode_title', '') if not c.rhodecode_name: c.rhodecode_name = 'Rhodecode' response = render_to_response('/errors/error_document.html', {'c': c}, request=request, response=base_response) return response
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 = url('admin_settings_issuetracker_save') post_data = { 'new_pattern_pattern_0': pattern, 'new_pattern_url_0': 'url', 'new_pattern_prefix_0': 'prefix', 'new_pattern_description_0': 'description', 'uid': old_uid, 'csrf_token': csrf_token } self.app.post(post_url, post_data, status=302) 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_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 == []
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
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
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_value_is_not_set_when_repository_is_not_specified( self, repo_stub): it_model = IssueTrackerSettingsModel() it_model.inherit_global_settings = False settings_model = SettingsModel(repo=repo_stub.repo_name) setting = settings_model.get_setting_by_name( IssueTrackerSettingsModel.INHERIT_SETTINGS) assert setting is None global_setting = it_model.global_settings.get_setting_by_name( IssueTrackerSettingsModel.INHERIT_SETTINGS) assert global_setting is None
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 == []
def set_rhodecode_config(config): """ Updates pylons config with new settings from database :param config: """ from rhodecode.model.settings import SettingsModel app_settings = SettingsModel().get_all_settings() for k, v in app_settings.items(): config[k] = v
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 password_reset(self): settings = SettingsModel().get_all_settings() captcha_private_key = settings.get('rhodecode_captcha_private_key') captcha_active = bool(captcha_private_key) captcha_public_key = settings.get('rhodecode_captcha_public_key') render_ctx = { 'captcha_active': captcha_active, 'captcha_public_key': captcha_public_key, 'defaults': {}, 'errors': {}, } if self.request.POST: password_reset_form = PasswordResetForm()() try: form_result = password_reset_form.to_python( self.request.params) if captcha_active: response = submit( self.request.params.get('recaptcha_challenge_field'), self.request.params.get('recaptcha_response_field'), private_key=captcha_private_key, remoteip=get_ip_addr(self.request.environ)) if captcha_active and not response.is_valid: _value = form_result _msg = _('bad captcha') error_dict = {'recaptcha_field': _msg} raise formencode.Invalid(_msg, _value, None, error_dict=error_dict) # Generate reset URL and send mail. user_email = form_result['email'] user = User.get_by_email(user_email) password_reset_url = self.request.route_url( 'reset_password_confirmation', _query={'key': user.api_key}) UserModel().reset_password_link( form_result, password_reset_url) # Display success message and redirect. self.session.flash( _('Your password reset link was sent'), queue='success') return HTTPFound(self.request.route_path('login')) except formencode.Invalid as errors: render_ctx.update({ 'defaults': errors.value, 'errors': errors.error_dict, }) return render_ctx
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_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
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}
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_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
def settings_hooks(self): """GET /admin/settings/hooks: All items in the collection""" # url('admin_settings_hooks') c.active = 'hooks' model = SettingsModel() c.hooks = model.get_builtin_hooks() c.custom_hooks = model.get_custom_hooks() return htmlfill.render(render('admin/settings/settings.html'), defaults=self._form_defaults(), encoding="UTF-8", force_defaults=False)
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_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
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
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_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
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_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_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_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()
def settings_visual_update(self): """POST /admin/settings/visual: All items in the collection""" # url('admin_settings_visual') c.active = 'visual' application_form = ApplicationVisualisationForm()() try: form_result = application_form.to_python(dict(request.POST)) except formencode.Invalid as errors: return htmlfill.render(render('admin/settings/settings.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) try: settings = [ ('show_public_icon', 'rhodecode_show_public_icon', 'bool'), ('show_private_icon', 'rhodecode_show_private_icon', 'bool'), ('stylify_metatags', 'rhodecode_stylify_metatags', 'bool'), ('repository_fields', 'rhodecode_repository_fields', 'bool'), ('dashboard_items', 'rhodecode_dashboard_items', 'int'), ('admin_grid_items', 'rhodecode_admin_grid_items', 'int'), ('show_version', 'rhodecode_show_version', 'bool'), ('use_gravatar', 'rhodecode_use_gravatar', 'bool'), ('markup_renderer', 'rhodecode_markup_renderer', 'unicode'), ('gravatar_url', 'rhodecode_gravatar_url', 'unicode'), ('clone_uri_tmpl', 'rhodecode_clone_uri_tmpl', 'unicode'), ('support_url', 'rhodecode_support_url', 'unicode'), ('show_revision_number', 'rhodecode_show_revision_number', 'bool'), ('show_sha_length', 'rhodecode_show_sha_length', 'int'), ] for setting, form_key, type_ in settings: sett = SettingsModel().create_or_update_setting( setting, form_result[form_key], type_) Session().add(sett) Session().commit() SettingsModel().invalidate_settings_cache() h.flash(_('Updated visualisation settings'), category='success') except Exception: log.exception("Exception updating visualization settings") h.flash(_('Error occurred during updating ' 'visualisation settings'), category='error') return redirect(url('admin_settings_visual'))
def test_post_ldap_group_settings(self, csrf_token): params = self._enable_plugins( 'egg:rhodecode-enterprise-ce#rhodecode,' 'egg:rhodecode-enterprise-ce#ldap', csrf_token) response = self._post_ldap_settings(params, override={ 'host': 'dc-legacy.example.com', 'port': '999', 'tls_kind': 'PLAIN', 'tls_reqcert': 'NEVER', 'dn_user': '******', 'dn_pass': '******', 'base_dn': 'test_base_dn', 'filter': 'test_filter', 'search_scope': 'BASE', 'attr_login': '******', 'attr_firstname': 'ima', 'attr_lastname': 'tester', 'attr_email': '*****@*****.**', 'auth_cache_ttl': '60', 'csrf_token': csrf_token, } ) assert_auth_settings_updated(response) new_settings = SettingsModel().get_auth_settings() assert new_settings['auth_ldap_host'] == u'dc-legacy.example.com', \ 'fail db write compare'
def get_setting_by_name(self, name, default=None): """ Returns a plugin setting by name. """ full_name = self._get_setting_full_name(name) db_setting = SettingsModel().get_setting_by_name(full_name) return db_setting.app_settings_value if db_setting else default