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_add_issuetracker_patterns(self, autologin_user, backend, csrf_token, request): pattern = 'issuetracker_pat' another_pattern = pattern + '1' post_url = url('repo_issuetracker_save', repo_name=backend.repo.repo_name) post_data = { 'new_pattern_pattern_0': pattern, 'new_pattern_url_0': 'url', 'new_pattern_prefix_0': 'prefix', 'new_pattern_description_0': 'description', 'new_pattern_pattern_1': another_pattern, 'new_pattern_url_1': 'url1', 'new_pattern_prefix_1': 'prefix1', 'new_pattern_description_1': 'description1', 'csrf_token': csrf_token } self.app.post(post_url, post_data, status=302) self.settings_model = IssueTrackerSettingsModel(repo=backend.repo) settings = self.settings_model.get_repo_settings() self.uid = md5(pattern) assert settings[self.uid]['pat'] == pattern self.another_uid = md5(another_pattern) assert settings[self.another_uid]['pat'] == another_pattern @request.addfinalizer def cleanup(): self.settings_model.delete_entries(self.uid) self.settings_model.delete_entries(self.another_uid)
def test_edit_issuetracker_pattern(self, autologin_user, backend, csrf_token, request): entry_key = 'issuetracker_pat_' pattern = 'issuetracker_pat2' old_pattern = 'issuetracker_pat' old_uid = md5(old_pattern) sett = SettingsModel(repo=backend.repo).create_or_update_setting( entry_key + old_uid, old_pattern, 'unicode') Session().add(sett) Session().commit() post_url = url('repo_issuetracker_save', repo_name=backend.repo.repo_name) post_data = { 'new_pattern_pattern_0': pattern, 'new_pattern_url_0': 'url', 'new_pattern_prefix_0': 'prefix', 'new_pattern_description_0': 'description', 'uid': old_uid, 'csrf_token': csrf_token } self.app.post(post_url, post_data, status=302) self.settings_model = IssueTrackerSettingsModel(repo=backend.repo) settings = self.settings_model.get_repo_settings() self.uid = md5(pattern) assert settings[self.uid]['pat'] == pattern with pytest.raises(KeyError): settings[old_uid] @request.addfinalizer def cleanup(): self.settings_model.delete_entries(self.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 = 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': 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 my_account_password_update(self): c.active = 'password' self.__load_data() _form = PasswordChangeForm(c.rhodecode_user.username)() try: form_result = _form.to_python(request.POST) UserModel().update_user(c.rhodecode_user.user_id, **form_result) instance = c.rhodecode_user.get_instance() instance.update_userdata(force_password_change=False) Session().commit() session.setdefault('rhodecode_user', {}).update({'password': md5(instance.password)}) session.save() h.flash(_("Successfully updated password"), category='success') except formencode.Invalid as errors: return htmlfill.render(render('admin/my_account/my_account.html'), defaults=errors.value, errors=errors.error_dict or {}, prefix_error=False, encoding="UTF-8", force_defaults=False) except Exception: log.exception("Exception updating password") h.flash(_('Error occurred during update of user password'), category='error') return render('admin/my_account/my_account.html')
def password_changed(auth_user, session): if auth_user.username == User.DEFAULT_USER: return False password_hash = md5(auth_user.password) if auth_user.password else None rhodecode_user = session.get('rhodecode_user', {}) session_password_hash = rhodecode_user.get('password', '') return password_hash != session_password_hash
def test_auth_user_get_cookie_store_for_default_user(): default_user = User.get_default_user() auth_user = auth.AuthUser() expected_data = { 'username': User.DEFAULT_USER, 'user_id': default_user.user_id, 'password': md5(default_user.password), 'is_authenticated': True } assert auth_user.get_cookie_store() == expected_data
def test_auth_user_get_cookie_store_for_normal_user(user_util): user = user_util.create_user() auth_user = auth.AuthUser(user_id=user.user_id) expected_data = { 'username': user.username, 'user_id': user.user_id, 'password': md5(user.password), 'is_authenticated': False } assert auth_user.get_cookie_store() == expected_data
def test_add_issuetracker_pattern( self, request, autologin_user, csrf_token): pattern = 'issuetracker_pat' another_pattern = pattern+'1' 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', 'new_pattern_pattern_1': another_pattern, 'new_pattern_url_1': 'url1', 'new_pattern_prefix_1': 'prefix1', 'new_pattern_description_1': 'description1', 'csrf_token': csrf_token } self.app.post(post_url, post_data, status=302) 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_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 = url('admin_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
def test_delete_issuetracker_pattern(self, autologin_user, backend, csrf_token, settings_util): repo = backend.create_repo() entry_key = 'issuetracker_pat_' pattern = 'issuetracker_pat3' uid = md5(pattern) settings_util.create_repo_rhodecode_setting(repo=backend.repo, name=entry_key + uid, value=entry_key, type_='unicode', cleanup=False) self.app.post(url('repo_issuetracker_delete', repo_name=backend.repo.repo_name), { '_method': 'delete', 'uid': uid, 'csrf_token': csrf_token }, status=302) settings = IssueTrackerSettingsModel(repo=repo).get_repo_settings() assert 'rhodecode_%s%s' % (entry_key, uid) not in settings
def _to_python(self, value, state): patterns = [] prefix = 'new_pattern' for name, v in value.iteritems(): pattern_name = '_'.join((prefix, 'pattern')) if name.startswith(pattern_name): new_item_id = name[len(pattern_name)+1:] def _field(name): return '%s_%s_%s' % (prefix, name, new_item_id) values = { 'issuetracker_pat': value.get(_field('pattern')), 'issuetracker_pat': value.get(_field('pattern')), 'issuetracker_url': value.get(_field('url')), 'issuetracker_pref': value.get(_field('prefix')), 'issuetracker_desc': value.get(_field('description')) } new_uid = md5(values['issuetracker_pat']) has_required_fields = ( values['issuetracker_pat'] and values['issuetracker_url']) if has_required_fields: settings = [ ('_'.join((key, new_uid)), values[key], 'unicode') for key in values] patterns.append(settings) value['patterns'] = patterns delete_patterns = value.get('uid') or [] if not isinstance(delete_patterns, (list, tuple)): delete_patterns = [delete_patterns] value['delete_patterns'] = delete_patterns return value
def attach_context_attributes(context): rc_config = SettingsModel().get_all_settings(cache=True) context.rhodecode_version = rhodecode.__version__ context.rhodecode_edition = config.get('rhodecode.edition') # unique secret + version does not leak the version but keep consistency context.rhodecode_version_hash = md5( config.get('beaker.session.secret', '') + rhodecode.__version__)[:8] # Default language set for the incoming request context.language = translation.get_lang()[0] # Visual options context.visual = AttributeDict({}) # DB store context.visual.show_public_icon = str2bool( rc_config.get('rhodecode_show_public_icon')) context.visual.show_private_icon = str2bool( rc_config.get('rhodecode_show_private_icon')) context.visual.stylify_metatags = str2bool( rc_config.get('rhodecode_stylify_metatags')) context.visual.dashboard_items = safe_int( rc_config.get('rhodecode_dashboard_items', 100)) context.visual.admin_grid_items = safe_int( rc_config.get('rhodecode_admin_grid_items', 100)) context.visual.repository_fields = str2bool( rc_config.get('rhodecode_repository_fields')) context.visual.show_version = str2bool( rc_config.get('rhodecode_show_version')) context.visual.use_gravatar = str2bool( rc_config.get('rhodecode_use_gravatar')) context.visual.gravatar_url = rc_config.get('rhodecode_gravatar_url') context.visual.default_renderer = rc_config.get( 'rhodecode_markup_renderer', 'rst') context.visual.rhodecode_support_url = \ rc_config.get('rhodecode_support_url') or url('rhodecode_support') context.pre_code = rc_config.get('rhodecode_pre_code') context.post_code = rc_config.get('rhodecode_post_code') context.rhodecode_name = rc_config.get('rhodecode_title') context.default_encodings = aslist(config.get('default_encoding'), sep=',') # if we have specified default_encoding in the request, it has more # priority if request.GET.get('default_encoding'): context.default_encodings.insert(0, request.GET.get('default_encoding')) context.clone_uri_tmpl = rc_config.get('rhodecode_clone_uri_tmpl') # INI stored context.labs_active = str2bool( config.get('labs_settings_active', 'false')) context.visual.allow_repo_location_change = str2bool( config.get('allow_repo_location_change', True)) context.visual.allow_custom_hooks_settings = str2bool( config.get('allow_custom_hooks_settings', True)) context.debug_style = str2bool(config.get('debug_style', False)) context.rhodecode_instanceid = config.get('instance_id') # AppEnlight context.appenlight_enabled = str2bool(config.get('appenlight', 'false')) context.appenlight_api_public_key = config.get( 'appenlight.api_public_key', '') context.appenlight_server_url = config.get('appenlight.server_url', '') # END CONFIG VARS # TODO: This dosn't work when called from pylons compatibility tween. # Fix this and remove it from base controller. # context.repo_name = get_repo_slug(request) # can be empty context.csrf_token = auth.get_csrf_token() context.backends = rhodecode.BACKENDS.keys() context.backends.sort() context.unread_notifications = NotificationModel().get_unread_cnt_for_user( context.rhodecode_user.user_id)
def get_nodes(self, repo_name, commit_id, root_path='/', flat=True, extended_info=False, content=False): """ recursive walk in root dir and return a set of all path in that dir based on repository walk function :param repo_name: name of repository :param commit_id: commit id for which to list nodes :param root_path: root path to list :param flat: return as a list, if False returns a dict with decription """ _files = list() _dirs = list() try: _repo = self._get_repo(repo_name) commit = _repo.scm_instance().get_commit(commit_id=commit_id) root_path = root_path.lstrip('/') for __, dirs, files in commit.walk(root_path): for f in files: _content = None _data = f.unicode_path if not flat: _data = { "name": f.unicode_path, "type": "file", } if extended_info: _content = safe_str(f.content) _data.update({ "md5": md5(_content), "binary": f.is_binary, "size": f.size, "extension": f.extension, "mimetype": f.mimetype, "lines": f.lines()[0] }) if content: full_content = None if not f.is_binary: # in case we loaded the _content already # re-use it, or load from f[ile] full_content = _content or safe_str(f.content) _data.update({"content": full_content}) _files.append(_data) for d in dirs: _data = d.unicode_path if not flat: _data = { "name": d.unicode_path, "type": "dir", } if extended_info: _data.update({ "md5": None, "binary": None, "size": None, "extension": None, }) if content: _data.update({"content": None}) _dirs.append(_data) except RepositoryError: log.debug("Exception in get_nodes", exc_info=True) raise return _dirs, _files
def test_returns_false_if_password_was_not_changed(self): self.session['rhodecode_user']['password'] = md5( self.auth_user.password) result = utils.password_changed(self.auth_user, self.session) assert result is False