tooltips: small fixes/tests fixes.

rhodecode/apps/home/tests/test_home.py

@@ -1,141 +1,127 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 rhodecode
 from rhodecode.model.db import Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.settings import SettingsModel
 from rhodecode.tests import TestController
 from rhodecode.tests.fixture import Fixture
 from rhodecode.lib import helpers as h
 
 fixture = Fixture()
 
 
 def route_path(name, **kwargs):
     return {
         'home': '/',
         'repo_group_home': '/{repo_group_name}'
     }[name].format(**kwargs)
 
 
 class TestHomeController(TestController):
 
     def test_index(self):
         self.log_user()
         response = self.app.get(route_path('home'))
         # if global permission is set
         response.mustcontain('New Repository')
 
         # search for objects inside the JavaScript JSON
         for repo in Repository.getAll():
             response.mustcontain('"name_raw": "%s"' % repo.repo_name)
 
     def test_index_contains_statics_with_ver(self):
         from rhodecode.lib.base import calculate_version_hash
 
         self.log_user()
         response = self.app.get(route_path('home'))
 
         rhodecode_version_hash = calculate_version_hash(
             {'beaker.session.secret': 'test-rc-uytcxaz'})
         response.mustcontain('style.css?ver={0}'.format(rhodecode_version_hash))
         response.mustcontain('scripts.min.js?ver={0}'.format(rhodecode_version_hash))
 
     def test_index_contains_backend_specific_details(self, backend):
         self.log_user()
         response = self.app.get(route_path('home'))
         tip = backend.repo.get_commit().raw_id
 
         # html in javascript variable:
         response.mustcontain(r'<i class=\"icon-%s\"' % (backend.alias, ))
         response.mustcontain(r'href=\"/%s\"' % (backend.repo_name, ))
 
         response.mustcontain("""/%s/changeset/%s""" % (backend.repo_name, tip))
         response.mustcontain("""Added a symlink""")
 
     def test_index_with_anonymous_access_disabled(self):
         with fixture.anon_access(False):
             response = self.app.get(route_path('home'), status=302)
             assert 'login' in response.location
 
     def test_index_page_on_groups(self, autologin_user, repo_group):
         response = self.app.get(route_path('repo_group_home', repo_group_name='gr1'))
         response.mustcontain("gr1/repo_in_group")
 
     def test_index_page_on_group_with_trailing_slash(
             self, autologin_user, repo_group):
         response = self.app.get(route_path('repo_group_home', repo_group_name='gr1') + '/')
         response.mustcontain("gr1/repo_in_group")
 
     @pytest.fixture(scope='class')
     def repo_group(self, request):
         gr = fixture.create_repo_group('gr1')
         fixture.create_repo(name='gr1/repo_in_group', repo_group=gr)
 
         @request.addfinalizer
         def cleanup():
             RepoModel().delete('gr1/repo_in_group')
             RepoGroupModel().delete(repo_group='gr1', force_delete=True)
             Session().commit()
 
-    def test_index_with_name_with_tags(self, user_util, autologin_user):
-        user = user_util.create_user()
-        username = user.username
-        user.name = '<img src="/image1" onload="alert(\'Hello, World!\');">'
-        user.lastname = '#"><img src=x onerror=prompt(document.cookie);>'
-
-        Session().add(user)
-        Session().commit()
-        user_util.create_repo(owner=username)
-
-        response = self.app.get(route_path('home'))
-        response.mustcontain(h.html_escape(user.first_name))
-        response.mustcontain(h.html_escape(user.last_name))
-
     @pytest.mark.parametrize("name, state", [
         ('Disabled', False),
         ('Enabled', True),
     ])
     def test_index_show_version(self, autologin_user, name, state):
         version_string = 'RhodeCode Enterprise %s' % rhodecode.__version__
 
         sett = SettingsModel().create_or_update_setting(
             'show_version', state, 'bool')
         Session().add(sett)
         Session().commit()
         SettingsModel().invalidate_settings_cache()
 
         response = self.app.get(route_path('home'))
         if state is True:
             response.mustcontain(version_string)
         if state is False:
             response.mustcontain(no=[version_string])
 
     def test_logout_form_contains_csrf(self, autologin_user, csrf_token):
         response = self.app.get(route_path('home'))
         assert_response = response.assert_response()
         element = assert_response.get_element('.logout #csrf_token')
         assert element.value == csrf_token

rhodecode/apps/repository/tests/test_repo_issue_tracker.py

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

rhodecode/templates/data_table/_dt_elements.mako

@@ -1,469 +1,469 b''
 ## DATA TABLE RE USABLE ELEMENTS
 ## usage:
 ## <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
 <%namespace name="base" file="/base/base.mako"/>
 
 <%def name="metatags_help()">
     <table>
         <%
             example_tags = [
                 ('state','[stable]'),
                 ('state','[stale]'),
                 ('state','[featured]'),
                 ('state','[dev]'),
                 ('state','[dead]'),
                 ('state','[deprecated]'),
 
                 ('label','[personal]'),
                 ('generic','[v2.0.0]'),
 
                 ('lang','[lang =&gt; JavaScript]'),
                 ('license','[license =&gt; LicenseName]'),
 
                 ('ref','[requires =&gt; RepoName]'),
                 ('ref','[recommends =&gt; GroupName]'),
                 ('ref','[conflicts =&gt; SomeName]'),
                 ('ref','[base =&gt; SomeName]'),
                 ('url','[url =&gt; [linkName](https://rhodecode.com)]'),
                 ('see','[see =&gt; http://rhodecode.com]'),
             ]
         %>
         % for tag_type, tag in example_tags:
             <tr>
                 <td>${tag|n}</td>
                 <td>${h.style_metatag(tag_type, tag)|n}</td>
             </tr>
         % endfor
     </table>
 </%def>
 
 <%def name="render_description(description, stylify_metatags)">
 <%
     tags = []
     if stylify_metatags:
         tags, description = h.extract_metatags(description)
 %>
 % for tag_type, tag in tags:
 ${h.style_metatag(tag_type, tag)|n,trim}
 % endfor
 <code style="white-space: pre-wrap">${description}</code>
 </%def>
 
 ## REPOSITORY RENDERERS
 <%def name="quick_menu(repo_name)">
   <i class="icon-more"></i>
   <div class="menu_items_container hidden">
     <ul class="menu_items">
       <li>
          <a title="${_('Summary')}" href="${h.route_path('repo_summary',repo_name=repo_name)}">
          <span>${_('Summary')}</span>
          </a>
       </li>
       <li>
          <a title="${_('Commits')}" href="${h.route_path('repo_commits',repo_name=repo_name)}">
          <span>${_('Commits')}</span>
          </a>
       </li>
       <li>
          <a title="${_('Files')}" href="${h.route_path('repo_files:default_commit',repo_name=repo_name)}">
          <span>${_('Files')}</span>
          </a>
       </li>
       <li>
          <a title="${_('Fork')}" href="${h.route_path('repo_fork_new',repo_name=repo_name)}">
          <span>${_('Fork')}</span>
          </a>
       </li>
     </ul>
   </div>
 </%def>
 
 <%def name="repo_name(name,rtype,rstate,private,archived,fork_of,short_name=False,admin=False)">
     <%
     def get_name(name,short_name=short_name):
       if short_name:
         return name.split('/')[-1]
       else:
         return name
     %>
   <div class="${'repo_state_pending' if rstate == 'repo_state_pending' else ''} truncate">
     ##NAME
     <a href="${h.route_path('edit_repo',repo_name=name) if admin else h.route_path('repo_summary',repo_name=name)}">
 
     ##TYPE OF REPO
     %if h.is_hg(rtype):
         <span title="${_('Mercurial repository')}"><i class="icon-hg" style="font-size: 14px;"></i></span>
     %elif h.is_git(rtype):
         <span title="${_('Git repository')}"><i class="icon-git" style="font-size: 14px"></i></span>
     %elif h.is_svn(rtype):
         <span title="${_('Subversion repository')}"><i class="icon-svn" style="font-size: 14px"></i></span>
     %endif
 
     ##PRIVATE/PUBLIC
     %if private is True and c.visual.show_private_icon:
       <i class="icon-lock" title="${_('Private repository')}"></i>
     %elif private is False and c.visual.show_public_icon:
       <i class="icon-unlock-alt" title="${_('Public repository')}"></i>
     %else:
       <span></span>
     %endif
     ${get_name(name)}
     </a>
     %if fork_of:
       <a href="${h.route_path('repo_summary',repo_name=fork_of.repo_name)}"><i class="icon-code-fork"></i></a>
     %endif
     %if rstate == 'repo_state_pending':
       <span class="creation_in_progress tooltip" title="${_('This repository is being created in a background task')}">
           (${_('creating...')})
       </span>
     %endif
 
   </div>
 </%def>
 
 <%def name="repo_desc(description, stylify_metatags)">
     <%
     tags, description = h.extract_metatags(description)
     %>
 
     <div class="truncate-wrap">
         % if stylify_metatags:
             % for tag_type, tag in tags:
                 ${h.style_metatag(tag_type, tag)|n}
             % endfor
         % endif
         ${description}
     </div>
 
 </%def>
 
 <%def name="last_change(last_change)">
     ${h.age_component(last_change, time_is_local=True)}
 </%def>
 
 <%def name="revision(repo_name, rev, commit_id, author, last_msg, commit_date)">
   <div>
   %if rev >= 0:
-      <code><a class="tooltip-hovercard" data-hovercard-alt="${last_msg}" data-hovercard-url="${h.route_path('hovercard_repo_commit', repo_name=repo_name, commit_id=commit_id)}" href="${h.route_path('repo_commit',repo_name=repo_name,commit_id=commit_id)}">${'r{}:{}'.format(rev,h.short_id(commit_id))}</a></code>
+      <code><a class="tooltip-hovercard" data-hovercard-alt=${h.tooltip(last_msg)} data-hovercard-url="${h.route_path('hovercard_repo_commit', repo_name=repo_name, commit_id=commit_id)}" href="${h.route_path('repo_commit',repo_name=repo_name,commit_id=commit_id)}">${'r{}:{}'.format(rev,h.short_id(commit_id))}</a></code>
   %else:
       ${_('No commits yet')}
   %endif
   </div>
 </%def>
 
 <%def name="rss(name)">
   %if c.rhodecode_user.username != h.DEFAULT_USER:
     <a title="${h.tooltip(_('Subscribe to %s rss feed')% name)}" href="${h.route_path('rss_feed_home', repo_name=name, _query=dict(auth_token=c.rhodecode_user.feed_token))}"><i class="icon-rss-sign"></i></a>
   %else:
     <a title="${h.tooltip(_('Subscribe to %s rss feed')% name)}" href="${h.route_path('rss_feed_home', repo_name=name)}"><i class="icon-rss-sign"></i></a>
   %endif
 </%def>
 
 <%def name="atom(name)">
   %if c.rhodecode_user.username != h.DEFAULT_USER:
     <a title="${h.tooltip(_('Subscribe to %s atom feed')% name)}" href="${h.route_path('atom_feed_home', repo_name=name, _query=dict(auth_token=c.rhodecode_user.feed_token))}"><i class="icon-rss-sign"></i></a>
   %else:
     <a title="${h.tooltip(_('Subscribe to %s atom feed')% name)}" href="${h.route_path('atom_feed_home', repo_name=name)}"><i class="icon-rss-sign"></i></a>
   %endif
 </%def>
 
 <%def name="repo_actions(repo_name, super_user=True)">
   <div>
     <div class="grid_edit">
       <a href="${h.route_path('edit_repo',repo_name=repo_name)}" title="${_('Edit')}">
         Edit
       </a>
     </div>
     <div class="grid_delete">
       ${h.secure_form(h.route_path('edit_repo_advanced_delete', repo_name=repo_name), request=request)}
         ${h.submit('remove_%s' % repo_name,_('Delete'),class_="btn btn-link btn-danger",
         onclick="return confirm('"+_('Confirm to delete this repository: %s') % repo_name+"');")}
       ${h.end_form()}
     </div>
   </div>
 </%def>
 
 <%def name="repo_state(repo_state)">
   <div>
     %if repo_state == 'repo_state_pending':
         <div class="tag tag4">${_('Creating')}</div>
     %elif repo_state == 'repo_state_created':
         <div class="tag tag1">${_('Created')}</div>
     %else:
         <div class="tag alert2" title="${h.tooltip(repo_state)}">invalid</div>
     %endif
   </div>
 </%def>
 
 
 ## REPO GROUP RENDERERS
 <%def name="quick_repo_group_menu(repo_group_name)">
   <i class="icon-more"></i>
   <div class="menu_items_container hidden">
     <ul class="menu_items">
       <li>
          <a href="${h.route_path('repo_group_home', repo_group_name=repo_group_name)}">${_('Summary')}</a>
       </li>
 
     </ul>
   </div>
 </%def>
 
 <%def name="repo_group_name(repo_group_name, children_groups=None)">
   <div>
     <a href="${h.route_path('repo_group_home', repo_group_name=repo_group_name)}">
     <i class="icon-repo-group" title="${_('Repository group')}" style="font-size: 14px"></i>
       %if children_groups:
           ${h.literal(' &raquo; '.join(children_groups))}
       %else:
           ${repo_group_name}
       %endif
   </a>
   </div>
 </%def>
 
 <%def name="repo_group_desc(description, personal, stylify_metatags)">
 
     <%
         if stylify_metatags:
             tags, description = h.extract_metatags(description)
     %>
 
     <div class="truncate-wrap">
         % if personal:
             <div class="metatag" tag="personal">${_('personal')}</div>
         % endif
 
         % if stylify_metatags:
             % for tag_type, tag in tags:
                 ${h.style_metatag(tag_type, tag)|n}
             % endfor
         % endif
         ${description}
     </div>
 
 </%def>
 
 <%def name="repo_group_actions(repo_group_id, repo_group_name, gr_count)">
  <div class="grid_edit">
     <a href="${h.route_path('edit_repo_group',repo_group_name=repo_group_name)}" title="${_('Edit')}">Edit</a>
  </div>
  <div class="grid_delete">
     ${h.secure_form(h.route_path('edit_repo_group_advanced_delete', repo_group_name=repo_group_name), request=request)}
         ${h.submit('remove_%s' % repo_group_name,_('Delete'),class_="btn btn-link btn-danger",
         onclick="return confirm('"+_ungettext('Confirm to delete this group: %s with %s repository','Confirm to delete this group: %s with %s repositories',gr_count) % (repo_group_name, gr_count)+"');")}
     ${h.end_form()}
  </div>
 </%def>
 
 
 <%def name="user_actions(user_id, username)">
  <div class="grid_edit">
    <a href="${h.route_path('user_edit',user_id=user_id)}" title="${_('Edit')}">
      ${_('Edit')}
    </a>
  </div>
  <div class="grid_delete">
   ${h.secure_form(h.route_path('user_delete', user_id=user_id), request=request)}
     ${h.submit('remove_',_('Delete'),id="remove_user_%s" % user_id, class_="btn btn-link btn-danger",
     onclick="return confirm('"+_('Confirm to delete this user: %s') % username+"');")}
   ${h.end_form()}
  </div>
 </%def>
 
 <%def name="user_group_actions(user_group_id, user_group_name)">
  <div class="grid_edit">
     <a href="${h.route_path('edit_user_group', user_group_id=user_group_id)}" title="${_('Edit')}">Edit</a>
  </div>
  <div class="grid_delete">
     ${h.secure_form(h.route_path('user_groups_delete', user_group_id=user_group_id), request=request)}
       ${h.submit('remove_',_('Delete'),id="remove_group_%s" % user_group_id, class_="btn btn-link btn-danger",
       onclick="return confirm('"+_('Confirm to delete this user group: %s') % user_group_name+"');")}
     ${h.end_form()}
  </div>
 </%def>
 
 
 <%def name="user_name(user_id, username)">
     ${h.link_to(h.person(username, 'username_or_name_or_email'), h.route_path('user_edit', user_id=user_id))}
 </%def>
 
 <%def name="user_profile(username)">
     ${base.gravatar_with_user(username, 16, tooltip=True)}
 </%def>
 
 <%def name="user_group_name(user_group_name)">
   <div>
       <i class="icon-user-group" title="${_('User group')}"></i>
       ${h.link_to_group(user_group_name)}
   </div>
 </%def>
 
 
 ## GISTS
 
 <%def name="gist_gravatar(full_contact)">
     <div class="gist_gravatar">
       ${base.gravatar(full_contact, 30)}
     </div>
 </%def>
 
 <%def name="gist_access_id(gist_access_id, full_contact)">
     <div>
       <b>
         <a href="${h.route_path('gist_show', gist_id=gist_access_id)}">gist: ${gist_access_id}</a>
       </b>
     </div>
 </%def>
 
 <%def name="gist_author(full_contact, created_on, expires)">
     ${base.gravatar_with_user(full_contact, 16, tooltip=True)}
 </%def>
 
 
 <%def name="gist_created(created_on)">
     <div class="created">
       ${h.age_component(created_on, time_is_local=True)}
     </div>
 </%def>
 
 <%def name="gist_expires(expires)">
     <div class="created">
           %if expires == -1:
             ${_('never')}
           %else:
             ${h.age_component(h.time_to_utcdatetime(expires))}
           %endif
     </div>
 </%def>
 
 <%def name="gist_type(gist_type)">
     %if gist_type != 'public':
       <div class="tag">${_('Private')}</div>
     %endif
 </%def>
 
 <%def name="gist_description(gist_description)">
   ${gist_description}
 </%def>
 
 
 ## PULL REQUESTS GRID RENDERERS
 
 <%def name="pullrequest_target_repo(repo_name)">
     <div class="truncate">
       ${h.link_to(repo_name,h.route_path('repo_summary',repo_name=repo_name))}
     </div>
 </%def>
 
 <%def name="pullrequest_status(status)">
     <i class="icon-circle review-status-${status}"></i>
 </%def>
 
 <%def name="pullrequest_title(title, description)">
     ${title}
 </%def>
 
 <%def name="pullrequest_comments(comments_nr)">
     <i class="icon-comment"></i> ${comments_nr}
 </%def>
 
 <%def name="pullrequest_name(pull_request_id, target_repo_name, short=False)">
     <a href="${h.route_path('pullrequest_show',repo_name=target_repo_name,pull_request_id=pull_request_id)}">
       % if short:
         #${pull_request_id}
       % else:
         ${_('Pull request #%(pr_number)s') % {'pr_number': pull_request_id,}}
       % endif
     </a>
 </%def>
 
 <%def name="pullrequest_updated_on(updated_on)">
     ${h.age_component(h.time_to_utcdatetime(updated_on))}
 </%def>
 
 <%def name="pullrequest_author(full_contact)">
     ${base.gravatar_with_user(full_contact, 16, tooltip=True)}
 </%def>
 
 
 ## ARTIFACT RENDERERS
 <%def name="repo_artifact_name(repo_name, file_uid, artifact_display_name)">
     <a href="${h.route_path('repo_artifacts_get', repo_name=repo_name, uid=file_uid)}">
         ${artifact_display_name or '_EMPTY_NAME_'}
     </a>
 </%def>
 
 <%def name="repo_artifact_uid(repo_name, file_uid)">
     <code>${h.shorter(file_uid, size=24, prefix=True)}</code>
     <i class="tooltip icon-clipboard clipboard-action" data-clipboard-text="${h.route_url('repo_artifacts_get', repo_name=repo_name, uid=file_uid)}" title="${_('Copy the full url')}"></i>
 </%def>
 
 <%def name="repo_artifact_sha256(artifact_sha256)">
     <div class="code">${h.shorter(artifact_sha256, 12)}<i class="tooltip icon-clipboard clipboard-action" data-clipboard-text="${artifact_sha256}" title="${_('Copy the sha256 ({})').format(artifact_sha256)}"></i></div>
 </%def>
 
 <%def name="repo_artifact_actions(repo_name, file_store_id, file_uid)">
 ##  <div class="grid_edit">
 ##     <a href="#Edit" title="${_('Edit')}">${_('Edit')}</a>
 ##  </div>
 <div class="grid_edit">
     <a href="${h.route_path('repo_artifacts_info', repo_name=repo_name, uid=file_store_id)}" title="${_('Info')}">${_('Info')}</a>
 </div>
     % if h.HasRepoPermissionAny('repository.admin')(c.repo_name):
     <div class="grid_delete">
     ${h.secure_form(h.route_path('repo_artifacts_delete', repo_name=repo_name, uid=file_store_id), request=request)}
       ${h.submit('remove_',_('Delete'),id="remove_artifact_%s" % file_store_id, class_="btn btn-link btn-danger",
       onclick="return confirm('"+_('Confirm to delete this artifact: %s') % file_uid+"');")}
     ${h.end_form()}
  </div>
 % endif
 </%def>
 
 <%def name="markup_form(form_id, form_text='', help_text=None)">
 
   <div class="markup-form">
     <div class="markup-form-area">
         <div class="markup-form-area-header">
             <ul class="nav-links clearfix">
                 <li class="active">
                     <a href="#edit-text" tabindex="-1" id="edit-btn_${form_id}">${_('Write')}</a>
                 </li>
                 <li class="">
                     <a href="#preview-text" tabindex="-1" id="preview-btn_${form_id}">${_('Preview')}</a>
                 </li>
             </ul>
         </div>
 
         <div class="markup-form-area-write" style="display: block;">
             <div id="edit-container_${form_id}">
                 <textarea id="${form_id}" name="${form_id}" class="comment-block-ta ac-input">${form_text if form_text else ''}</textarea>
             </div>
             <div id="preview-container_${form_id}" class="clearfix" style="display: none;">
                 <div id="preview-box_${form_id}" class="preview-box"></div>
             </div>
         </div>
 
         <div class="markup-form-area-footer">
             <div class="toolbar">
                 <div class="toolbar-text">
                   ${(_('Parsed using %s syntax') % (
                            ('<a href="%s">%s</a>' % (h.route_url('%s_help' % c.visual.default_renderer), c.visual.default_renderer.upper())),
                        )
                     )|n}
                 </div>
             </div>
         </div>
     </div>
 
     <div class="markup-form-footer">
         % if help_text:
             <span class="help-block">${help_text}</span>
         % endif
     </div>
   </div>
   <script type="text/javascript">
     new MarkupForm('${form_id}');
   </script>
 
 </%def>

rhodecode/tests/lib/test_helpers.py

@@ -1,235 +1,239 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 copy
 import mock
 import pytest
 
 from rhodecode.lib import helpers
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.model.settings import IssueTrackerSettingsModel
 from rhodecode.tests import no_newline_id_generator
 
 
 @pytest.mark.parametrize('url, expected_url', [
     ('http://rc.rc/test', '<a href="http://rc.rc/test">http://rc.rc/test</a>'),
     ('http://rc.rc/@foo', '<a href="http://rc.rc/@foo">http://rc.rc/@foo</a>'),
     ('http://rc.rc/!foo', '<a href="http://rc.rc/!foo">http://rc.rc/!foo</a>'),
     ('http://rc.rc/&foo', '<a href="http://rc.rc/&foo">http://rc.rc/&foo</a>'),
     ('http://rc.rc/#foo', '<a href="http://rc.rc/#foo">http://rc.rc/#foo</a>'),
 ])
 def test_urlify_text(url, expected_url):
     assert helpers.urlify_text(url) == expected_url
 
 
 @pytest.mark.parametrize('repo_name, commit_id, path, expected_result', [
     # Simple case 1
     ('repo', 'commit', 'a/b',
      '<a href="/repo/files/commit/"><i class="icon-home"></i></a>'
      ' / '
      '<a href="/repo/files/commit/a">a</a>'
      ' / '
      'b'),
 
     # Simple case
     ('rX<X', 'cX<X', 'pX<X/aX<X/bX<X',
      '<a href="/rX%3CX/files/cX%3CX/"><i class="icon-home"></i></a>'
      ' / '
      '<a href="/rX%3CX/files/cX%3CX/pX%3CX">pX&lt;X</a>'
      ' / '
      '<a href="/rX%3CX/files/cX%3CX/pX%3CX/aX%3CX">aX&lt;X</a>'
      ' / '
      'bX&lt;X'),
 
     # Path with only one segment
     ('rX<X', 'cX<X', 'pX<X',
      '<a href="/rX%3CX/files/cX%3CX/"><i class="icon-home"></i></a>'
      ' / '
      'pX&lt;X'),
 
     # Empty path
     ('rX<X', 'cX<X', '',
      '<i class="icon-home"></i>'),
 
     # simple quote
     ('rX"X', 'cX"X', 'pX"X/aX"X/bX"X',
      '<a href="/rX%22X/files/cX%22X/"><i class="icon-home"></i></a>'
      ' / '
      '<a href="/rX%22X/files/cX%22X/pX%22X">pX&#34;X</a>'
      ' / '
      '<a href="/rX%22X/files/cX%22X/pX%22X/aX%22X">aX&#34;X</a>'
      ' / '
      'bX&#34;X'),
 
 ], ids=['simple1', 'simple2', 'one_segment', 'empty_path', 'simple_quote'])
 def test_files_breadcrumbs_xss(
         repo_name, commit_id, path, app, expected_result):
     result = helpers.files_breadcrumbs(repo_name, commit_id, path)
     # Expect it to encode all path fragments properly. This is important
     # because it returns an instance of `literal`.
     if path != '':
         expected_result = expected_result + helpers.files_icon.format(helpers.escape(path))
     assert result == expected_result
 
 
 def test_format_binary():
     assert helpers.format_byte_size_binary(298489462784) == '278.0 GiB'
 
 
 @pytest.mark.parametrize('text_string, pattern, expected', [
     ('No issue here', '(?:#)(?P<issue_id>\d+)', []),
     ('Fix #42', '(?:#)(?P<issue_id>\d+)',
      [{'url': 'http://r.io/{repo}/i/42', 'id': '42'}]),
     ('Fix #42, #53', '(?:#)(?P<issue_id>\d+)', [
      {'url': 'http://r.io/{repo}/i/42', 'id': '42'},
      {'url': 'http://r.io/{repo}/i/53', 'id': '53'}]),
     ('Fix #42', '(?:#)?<issue_id>\d+)', []),  # Broken regex
 ])
 def test_extract_issues(backend, text_string, pattern, expected):
     repo = backend.create_repo()
     config = {
         '123': {
             'uid': '123',
             'pat': pattern,
             'url': 'http://r.io/${repo}/i/${issue_id}',
             'pref': '#',
+            'desc': 'Test Pattern'
         }
     }
 
     def get_settings_mock(self, cache=True):
         return config
 
     with mock.patch.object(IssueTrackerSettingsModel,
                            'get_settings', get_settings_mock):
         text, issues = helpers.process_patterns(text_string, repo.repo_name)
 
     expected = copy.deepcopy(expected)
     for item in expected:
         item['url'] = item['url'].format(repo=repo.repo_name)
 
     assert issues == expected
 
 
 @pytest.mark.parametrize('text_string, pattern, link_format, expected_text', [
     ('Fix #42', '(?:#)(?P<issue_id>\d+)', 'html',
-     'Fix <a class="issue-tracker-link" href="http://r.io/{repo}/i/42">#42</a>'),
+     'Fix <a class="tooltip issue-tracker-link" href="http://r.io/{repo}/i/42" title="Test Pattern">#42</a>'),
 
     ('Fix #42', '(?:#)(?P<issue_id>\d+)', 'markdown',
      'Fix [#42](http://r.io/{repo}/i/42)'),
 
     ('Fix #42', '(?:#)(?P<issue_id>\d+)', 'rst',
      'Fix `#42 <http://r.io/{repo}/i/42>`_'),
 
     ('Fix #42', '(?:#)?<issue_id>\d+)', 'html',
      'Fix #42'),  # Broken regex
 ])
 def test_process_patterns_repo(backend, text_string, pattern, expected_text, link_format):
     repo = backend.create_repo()
 
     def get_settings_mock(self, cache=True):
         return {
             '123': {
                 'uid': '123',
                 'pat': pattern,
                 'url': 'http://r.io/${repo}/i/${issue_id}',
                 'pref': '#',
+                'desc': 'Test Pattern'
             }
         }
 
     with mock.patch.object(IssueTrackerSettingsModel,
                            'get_settings', get_settings_mock):
         processed_text, issues = helpers.process_patterns(
             text_string, repo.repo_name, link_format)
 
     assert processed_text == expected_text.format(repo=repo.repo_name)
 
 
 @pytest.mark.parametrize('text_string, pattern, expected_text', [
     ('Fix #42', '(?:#)(?P<issue_id>\d+)',
-     'Fix <a class="issue-tracker-link" href="http://r.io/i/42">#42</a>'),
+     'Fix <a class="tooltip issue-tracker-link" href="http://r.io/i/42" title="Test Pattern">#42</a>'),
     ('Fix #42', '(?:#)?<issue_id>\d+)',
      'Fix #42'),  # Broken regex
 ])
 def test_process_patterns_no_repo(text_string, pattern, expected_text):
 
     def get_settings_mock(self, cache=True):
         return {
             '123': {
                 'uid': '123',
                 'pat': pattern,
                 'url': 'http://r.io/i/${issue_id}',
                 'pref': '#',
+                'desc': 'Test Pattern'
             }
         }
 
     with mock.patch.object(IssueTrackerSettingsModel,
                            'get_global_settings', get_settings_mock):
         processed_text, issues = helpers.process_patterns(
             text_string, '')
 
     assert processed_text == expected_text
 
 
 def test_process_patterns_non_existent_repo_name(backend):
     text_string = 'Fix #42'
     pattern = '(?:#)(?P<issue_id>\d+)'
-    expected_text = ('Fix <a class="issue-tracker-link" '
-                     'href="http://r.io/do-not-exist/i/42">#42</a>')
+    expected_text = ('Fix <a class="tooltip issue-tracker-link" '
+                     'href="http://r.io/do-not-exist/i/42" title="Test Pattern">#42</a>')
 
     def get_settings_mock(self, cache=True):
         return {
             '123': {
                 'uid': '123',
                 'pat': pattern,
                 'url': 'http://r.io/${repo}/i/${issue_id}',
                 'pref': '#',
+                'desc': 'Test Pattern'
             }
         }
 
     with mock.patch.object(IssueTrackerSettingsModel,
                            'get_global_settings', get_settings_mock):
         processed_text, issues = helpers.process_patterns(
             text_string, 'do-not-exist')
 
     assert processed_text == expected_text
 
 
 def test_get_visual_attr(baseapp):
     from rhodecode.apps._base import TemplateArgs
     c = TemplateArgs()
     assert None is helpers.get_visual_attr(c, 'fakse')
 
     # emulate the c.visual behaviour
     c.visual = AttributeDict({})
     assert None is helpers.get_visual_attr(c, 'some_var')
 
     c.visual.some_var = 'foobar'
     assert 'foobar' == helpers.get_visual_attr(c, 'some_var')
 
 
 @pytest.mark.parametrize('test_text, inclusive, expected_text', [
     ('just a string', False, 'just a string'),
     ('just a string\n', False, 'just a string'),
     ('just a string\n next line', False, 'just a string...'),
     ('just a string\n next line', True, 'just a string\n...'),
 ], ids=no_newline_id_generator)
 def test_chop_at(test_text, inclusive, expected_text):
     assert helpers.chop_at_smart(
         test_text, '\n', inclusive, '...') == expected_text