Changeset - d21c762f5c4b
Parent rev.
Child rev.
[Not reviewed]
beta
0 2 0
Marcin Kuzminski - 13 years ago 2013-02-19 20:35:25
marcin@python-works.com
revision extraction function shouldn't be so eager, just extract commits that are
surrounded with spaces, or they are at beginning of the whole string
- wrote tests for that
- used parametrized for other tests
2 files changed with 63 insertions and 18 deletions:
rhodecode/lib/helpers.py
7
2
rhodecode/tests/test_libs.py
56
16
0 comments (0 inline, 0 general)
rhodecode/lib/helpers.py
➞
Show inline comments
 
@@ -951,114 +951,119 @@ def fancy_file_stats(stats):
 
        return literal('<div style="width:%spx">%s%s</div>' % (width, b_a, b_d))
 

			




	
	
	
		
 
    t = stats[0] + stats[1]

			




	
	
	
		
 
    unit = float(width) / (t or 1)

			




	
	
	
		
 

			




	
	
	
		
 
    # needs > 9% of width to be visible or 0 to be hidden

			




	
	
	
		
 
    a_p = max(9, unit * a) if a > 0 else 0

			




	
	
	
		
 
    d_p = max(9, unit * d) if d > 0 else 0

			




	
	
	
		
 
    p_sum = a_p + d_p

			




	
	
	
		
 

			




	
	
	
		
 
    if p_sum > width:

			




	
	
	
		
 
        #adjust the percentage to be == 100% since we adjusted to 9

			




	
	
	
		
 
        if a_p > d_p:

			




	
	
	
		
 
            a_p = a_p - (p_sum - width)

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            d_p = d_p - (p_sum - width)

			




	
	
	
		
 

			




	
	
	
		
 
    a_v = a if a > 0 else ''

			




	
	
	
		
 
    d_v = d if d > 0 else ''

			




	
	
	
		
 

			




	
	
	
		
 
    d_a = '<div class="added %s" style="width:%s%%">%s</div>' % (

			




	
	
	
		
 
        cgen('a', a_v, d_v), a_p, a_v

			




	
	
	
		
 
    )

			




	
	
	
		
 
    d_d = '<div class="deleted %s" style="width:%s%%">%s</div>' % (

			




	
	
	
		
 
        cgen('d', a_v, d_v), d_p, d_v

			




	
	
	
		
 
    )

			




	
	
	
		
 
    return literal('<div style="width:%spx">%s%s</div>' % (width, d_a, d_d))

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def urlify_text(text_):

			




	
	
	
		
 

			




	
	
	
		
 
    url_pat = re.compile(r'''(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]'''

			




	
	
	
		
 
                         '''|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)''')

			




	
	
	
		
 

			




	
	
	
		
 
    def url_func(match_obj):

			




	
	
	
		
 
        url_full = match_obj.groups()[0]

			




	
	
	
		
 
        return '<a href="%(url)s">%(url)s</a>' % ({'url': url_full})

			




	
	
	
		
 

			




	
	
	
		
 
    return literal(url_pat.sub(url_func, text_))

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def urlify_changesets(text_, repository):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Extract revision ids from changeset and make link from them

			




	
	
	
		
 

			




	
	
	
		
 
    :param text_:

			




	
	
	
		
 
    :param repository:

			




	
	
	
		
 
    """

			




	
	
	
		
 

			




	
	
	
		
 
    URL_PAT = re.compile(r'([0-9a-fA-F]{12,})')

			




	
	
	
		
 
    from pylons import url  # doh, we need to re-import url to mock it later

			




	
	
	
		
 
    URL_PAT = re.compile(r'(?:^|\s)([0-9a-fA-F]{12,40})(?:$|\s)')

			




	
	
	
		
 

			




	
	
	
		
 
    def url_func(match_obj):

			




	
	
	
		
 
        rev = match_obj.groups()[0]

			




	
	
	
		
 
        pref = ''

			




	
	
	
		
 
        suf = ''

			




	
	
	
		
 
        if match_obj.group().startswith(' '):

			




	
	
	
		
 
            pref = ' '

			




	
	
	
		
 
        if match_obj.group().endswith(' '):

			




	
	
	
		
 
            suf = ' '

			




	
	
	
		
 
        tmpl = (

			




	
	
	
		
 
        '%(pref)s<a class="%(cls)s" href="%(url)s">'

			




	
	
	
		
 
        '%(rev)s'

			




	
	
	
		
 
        '</a>'

			




	
	
	
		
 
        '%(suf)s'

			




	
	
	
		
 
        )

			




	
	
	
		
 
        return tmpl % {

			




	
	
	
		
 
         'pref': pref,

			




	
	
	
		
 
         'cls': 'revision-link',

			




	
	
	
		
 
         'url': url('changeset_home', repo_name=repository, revision=rev),

			




	
	
	
		
 
         'rev': rev,

			




	
	
	
		
 
         'suf': suf

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
    newtext = URL_PAT.sub(url_func, text_)

			




	
	
	
		
 

			




	
	
	
		
 
    return newtext

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def urlify_commit(text_, repository=None, link_=None):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Parses given text message and makes proper links.

			




	
	
	
		
 
    issues are linked to given issue-server, and rest is a changeset link

			




	
	
	
		
 
    if link_ is given, in other case it's a plain text

			




	
	
	
		
 

			




	
	
	
		
 
    :param text_:

			




	
	
	
		
 
    :param repository:

			




	
	
	
		
 
    :param link_: changeset link

			




	
	
	
		
 
    """

			




	
	
	
		
 
    import traceback

			




	
	
	
		
 

			




	
	
	
		
 
    def escaper(string):

			




	
	
	
		
 
        return string.replace('<', '&lt;').replace('>', '&gt;')

			




	
	
	
		
 

			




	
	
	
		
 
    def linkify_others(t, l):

			




	
	
	
		
 
        urls = re.compile(r'(\<a.*?\<\/a\>)',)

			




	
	
	
		
 
        links = []

			




	
	
	
		
 
        for e in urls.split(t):

			




	
	
	
		
 
            if not urls.match(e):

			




	
	
	
		
 
                links.append('<a class="message-link" href="%s">%s</a>' % (l, e))

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                links.append(e)

			




	
	
	
		
 

			




	
	
	
		
 
        return ''.join(links)

			




	
	
	
		
 

			




	
	
	
		
 
    # urlify changesets - extrac revisions and make link out of them

			




	
	
	
		
 
    newtext = urlify_changesets(escaper(text_), repository)

			




	
	
	
		
 

			




	
	
	
		
 
    try:

			




	
	
	
		
 
        from rhodecode import CONFIG

			




	
	
	
		
 
        conf = CONFIG

			




	
	
	
		
 

			




	
	
	
		
 
        # allow multiple issue servers to be used

			




	
	
	
		
 
        valid_indices = [

			




	
	
	
		
 
            x.group(1)

			




	
	
	
		
 
            for x in map(lambda x: re.match(r'issue_pat(.*)', x), conf.keys())

			




	
	
	
		
 
            if x and 'issue_server_link%s' % x.group(1) in conf

			




	
	
	
		
 
            and 'issue_prefix%s' % x.group(1) in conf

			




	
	
	
		
 
        ]

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    rhodecode/tests/test_libs.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -21,131 +21,127 @@

			




	
	
	
		
 
# GNU General Public License for more details.

			




	
	
	
		
 
#

			




	
	
	
		
 
# You should have received a copy of the GNU General Public License

			




	
	
	
		
 
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
from __future__ import with_statement

			




	
	
	
		
 
import unittest

			




	
	
	
		
 
import datetime

			




	
	
	
		
 
import hashlib

			




	
	
	
		
 
import mock

			




	
	
	
		
 
from rhodecode.tests import *

			




	
	
	
		
 

			




	
	
	
		
 
proto = 'http'

			




	
	
	
		
 
TEST_URLS = [

			




	
	
	
		
 
    ('%s://127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://marcink@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://marcink:pass@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://127.0.0.1:8080' % proto, ['%s://' % proto, '127.0.0.1', '8080'],

			




	
	
	
		
 
     '%s://127.0.0.1:8080' % proto),

			




	
	
	
		
 
    ('%s://domain.org' % proto, ['%s://' % proto, 'domain.org'],

			




	
	
	
		
 
     '%s://domain.org' % proto),

			




	
	
	
		
 
    ('%s://user:pass@domain.org:8080' % proto, ['%s://' % proto, 'domain.org',

			




	
	
	
		
 
                                                '8080'],

			




	
	
	
		
 
     '%s://domain.org:8080' % proto),

			




	
	
	
		
 
]

			




	
	
	
		
 

			




	
	
	
		
 
proto = 'https'

			




	
	
	
		
 
TEST_URLS += [

			




	
	
	
		
 
    ('%s://127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://marcink@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://marcink:pass@127.0.0.1' % proto, ['%s://' % proto, '127.0.0.1'],

			




	
	
	
		
 
     '%s://127.0.0.1' % proto),

			




	
	
	
		
 
    ('%s://127.0.0.1:8080' % proto, ['%s://' % proto, '127.0.0.1', '8080'],

			




	
	
	
		
 
     '%s://127.0.0.1:8080' % proto),

			




	
	
	
		
 
    ('%s://domain.org' % proto, ['%s://' % proto, 'domain.org'],

			




	
	
	
		
 
     '%s://domain.org' % proto),

			




	
	
	
		
 
    ('%s://user:pass@domain.org:8080' % proto, ['%s://' % proto, 'domain.org',

			




	
	
	
		
 
                                                '8080'],

			




	
	
	
		
 
     '%s://domain.org:8080' % proto),

			




	
	
	
		
 
]

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class TestLibs(unittest.TestCase):

			




	
	
	
		
 

			




	
	
	
		
 
    def test_uri_filter(self):

			




	
	
	
		
 
    @parameterized.expand(TEST_URLS)

			




	
	
	
		
 
    def test_uri_filter(self, test_url, expected, expected_creds):

			




	
	
	
		
 
        from rhodecode.lib.utils2 import uri_filter

			




	
	
	
		
 
        self.assertEqual(uri_filter(test_url), expected)

			




	
	
	
		
 

			




	
	
	
		
 
        for url in TEST_URLS:

			




	
	
	
		
 
            self.assertEqual(uri_filter(url[0]), url[1])

			




	
	
	
		
 

			




	
	
	
		
 
    def test_credentials_filter(self):

			




	
	
	
		
 
    @parameterized.expand(TEST_URLS)

			




	
	
	
		
 
    def test_credentials_filter(self, test_url, expected, expected_creds):

			




	
	
	
		
 
        from rhodecode.lib.utils2 import credentials_filter

			




	
	
	
		
 

			




	
	
	
		
 
        for url in TEST_URLS:

			




	
	
	
		
 
            self.assertEqual(credentials_filter(url[0]), url[2])

			




	
	
	
		
 
        self.assertEqual(credentials_filter(test_url), expected_creds)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_str2bool(self):

			




	
	
	
		
 
        from rhodecode.lib.utils2 import str2bool

			




	
	
	
		
 
        test_cases = [

			




	
	
	
		
 
            ('t', True),

			




	
	
	
		
 
    @parameterized.expand([('t', True),

			




	
	
	
		
 
            ('true', True),

			




	
	
	
		
 
            ('y', True),

			




	
	
	
		
 
            ('yes', True),

			




	
	
	
		
 
            ('on', True),

			




	
	
	
		
 
            ('1', True),

			




	
	
	
		
 
            ('Y', True),

			




	
	
	
		
 
            ('yeS', True),

			




	
	
	
		
 
            ('Y', True),

			




	
	
	
		
 
            ('TRUE', True),

			




	
	
	
		
 
            ('T', True),

			




	
	
	
		
 
            ('False', False),

			




	
	
	
		
 
            ('F', False),

			




	
	
	
		
 
            ('FALSE', False),

			




	
	
	
		
 
            ('0', False),

			




	
	
	
		
 
            ('-1', False),

			




	
	
	
		
 
            ('', False), ]

			




	
	
	
		
 

			




	
	
	
		
 
        for case in test_cases:

			




	
	
	
		
 
            self.assertEqual(str2bool(case[0]), case[1])

			




	
	
	
		
 
                           ('', False)

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_str2bool(self, str_bool, expected):

			




	
	
	
		
 
        from rhodecode.lib.utils2 import str2bool

			




	
	
	
		
 
        self.assertEqual(str2bool(str_bool), expected)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_mention_extractor(self):

			




	
	
	
		
 
        from rhodecode.lib.utils2 import extract_mentioned_users

			




	
	
	
		
 
        sample = (

			




	
	
	
		
 
            "@first hi there @marcink here's my email marcin@email.com "

			




	
	
	
		
 
            "@lukaszb check @one_more22 it pls @ ttwelve @D[] @one@two@three "

			




	
	
	
		
 
            "@MARCIN    @maRCiN @2one_more22 @john please see this http://org.pl "

			




	
	
	
		
 
            "@marian.user just do it @marco-polo and next extract @marco_polo "

			




	
	
	
		
 
            "user.dot  hej ! not-needed maril@domain.org"

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        s = sorted([

			




	
	
	
		
 
        'first', 'marcink', 'lukaszb', 'one_more22', 'MARCIN', 'maRCiN', 'john',

			




	
	
	
		
 
        'marian.user', 'marco-polo', 'marco_polo'

			




	
	
	
		
 
        ], key=lambda k: k.lower())

			




	
	
	
		
 
        self.assertEqual(s, extract_mentioned_users(sample))

			




	
	
	
		
 

			




	
	
	
		
 
    def test_age(self):

			




	
	
	
		
 
        from rhodecode.lib.utils2 import age

			




	
	
	
		
 
        from dateutil import relativedelta

			




	
	
	
		
 
        n = datetime.datetime.now()

			




	
	
	
		
 
        delt = lambda *args, **kwargs: relativedelta.relativedelta(*args, **kwargs)

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(age(n), u'just now')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(seconds=-1)), u'1 second ago')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(seconds=-60 * 2)), u'2 minutes ago')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(hours=-1)), u'1 hour ago')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(hours=-24)), u'1 day ago')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(hours=-24 * 5)), u'5 days ago')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(months=-1)), u'1 month ago')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(months=-1, days=-2)), u'1 month and 2 days ago')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(years=-1, months=-1)), u'1 year and 1 month ago')

			




	
	
	
		
 

			




	
	
	
		
 
    def test_age_in_future(self):

			




	
	
	
		
 
        from rhodecode.lib.utils2 import age

			




	
	
	
		
 
        from dateutil import relativedelta

			




	
	
	
		
 
        n = datetime.datetime.now()

			




	
	
	
		
 
        delt = lambda *args, **kwargs: relativedelta.relativedelta(*args, **kwargs)

			




	
	
	
		
 

			




	
	
	
		
 
        self.assertEqual(age(n), u'just now')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(seconds=1)), u'in 1 second')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(seconds=60 * 2)), u'in 2 minutes')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(hours=1)), u'in 1 hour')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(hours=24)), u'in 1 day')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(hours=24 * 5)), u'in 5 days')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(months=1)), u'in 1 month')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(months=1, days=1)), u'in 1 month and 1 day')

			




	
	
	
		
 
        self.assertEqual(age(n + delt(years=1, months=1)), u'in 1 year and 1 month')

			




	
	
		
 
@@ -167,48 +163,92 @@ class TestLibs(unittest.TestCase):

			




	
	
	
		
 
        self.assertTrue('<div class="metatag" tag="tag">tag</div>' in res)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_alternative_gravatar(self):

			




	
	
	
		
 
        from rhodecode.lib.helpers import gravatar_url

			




	
	
	
		
 
        _md5 = lambda s: hashlib.md5(s).hexdigest()

			




	
	
	
		
 

			




	
	
	
		
 
        def fake_conf(**kwargs):

			




	
	
	
		
 
            from pylons import config

			




	
	
	
		
 
            config['app_conf'] = {}

			




	
	
	
		
 
            config['app_conf']['use_gravatar'] = True

			




	
	
	
		
 
            config['app_conf'].update(kwargs)

			




	
	
	
		
 
            return config

			




	
	
	
		
 

			




	
	
	
		
 
        class fake_url():

			




	
	
	
		
 
            @classmethod

			




	
	
	
		
 
            def current(cls, *args, **kwargs):

			




	
	
	
		
 
                return 'https://server.com'

			




	
	
	
		
 

			




	
	
	
		
 
        with mock.patch('pylons.url', fake_url):

			




	
	
	
		
 
            fake = fake_conf(alternative_gravatar_url='http://test.com/{email}')

			




	
	
	
		
 
            with mock.patch('pylons.config', fake):

			




	
	
	
		
 
                    from pylons import url

			




	
	
	
		
 
                    assert url.current() == 'https://server.com'

			




	
	
	
		
 
                    grav = gravatar_url(email_address='test@foo.com', size=24)

			




	
	
	
		
 
                    assert grav == 'http://test.com/test@foo.com'

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_conf(alternative_gravatar_url='http://test.com/{email}')

			




	
	
	
		
 
            with mock.patch('pylons.config', fake):

			




	
	
	
		
 
                grav = gravatar_url(email_address='test@foo.com', size=24)

			




	
	
	
		
 
                assert grav == 'http://test.com/test@foo.com'

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_conf(alternative_gravatar_url='http://test.com/{md5email}')

			




	
	
	
		
 
            with mock.patch('pylons.config', fake):

			




	
	
	
		
 
                em = 'test@foo.com'

			




	
	
	
		
 
                grav = gravatar_url(email_address=em, size=24)

			




	
	
	
		
 
                assert grav == 'http://test.com/%s' % (_md5(em))

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_conf(alternative_gravatar_url='http://test.com/{md5email}/{size}')

			




	
	
	
		
 
            with mock.patch('pylons.config', fake):

			




	
	
	
		
 
                em = 'test@foo.com'

			




	
	
	
		
 
                grav = gravatar_url(email_address=em, size=24)

			




	
	
	
		
 
                assert grav == 'http://test.com/%s/%s' % (_md5(em), 24)

			




	
	
	
		
 

			




	
	
	
		
 
            fake = fake_conf(alternative_gravatar_url='{scheme}://{netloc}/{md5email}/{size}')

			




	
	
	
		
 
            with mock.patch('pylons.config', fake):

			




	
	
	
		
 
                em = 'test@foo.com'

			




	
	
	
		
 
                grav = gravatar_url(email_address=em, size=24)

			




	
	
	
		
 
                assert grav == 'https://server.com/%s/%s' % (_md5(em), 24)

			




	
	
	
		
 

			




	
	
	
		
 
    @parameterized.expand([

			




	
	
	
		
 
      ("",

			




	
	
	
		
 
       ""),

			




	
	
	
		
 
      ("git-svn-id: https://svn.apache.org/repos/asf/libcloud/trunk@1441655 13f79535-47bb-0310-9956-ffa450edef68",

			




	
	
	
		
 
       "git-svn-id: https://svn.apache.org/repos/asf/libcloud/trunk@1441655 13f79535-47bb-0310-9956-ffa450edef68"),

			




	
	
	
		
 
      ("from rev 000000000000",

			




	
	
	
		
 
       "from rev url[000000000000]"),

			




	
	
	
		
 
      ("from rev 000000000000123123 also rev 000000000000",

			




	
	
	
		
 
       "from rev url[000000000000123123] also rev url[000000000000]"),

			




	
	
	
		
 
      ("this should-000 00",

			




	
	
	
		
 
       "this should-000 00"),

			




	
	
	
		
 
      ("longtextffffffffff rev 123123123123",

			




	
	
	
		
 
       "longtextffffffffff rev url[123123123123]"),

			




	
	
	
		
 
      ("rev ffffffffffffffffffffffffffffffffffffffffffffffffff",

			




	
	
	
		
 
       "rev ffffffffffffffffffffffffffffffffffffffffffffffffff"),

			




	
	
	
		
 
      ("ffffffffffff some text traalaa",

			




	
	
	
		
 
       "url[ffffffffffff] some text traalaa"),

			




	
	
	
		
 
       ("""Multi line

			




	
	
	
		
 
       123123123123 

			




	
	
	
		
 
       some text 123123123123""",

			




	
	
	
		
 
       """Multi line

			




	
	
	
		
 
       url[123123123123] 

			




	
	
	
		
 
       some text url[123123123123]""")

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_urlify_changesets(self, sample, expected):

			




	
	
	
		
 
        import re

			




	
	
	
		
 

			




	
	
	
		
 
        def fake_url(self, *args, **kwargs):

			




	
	
	
		
 
            return '/some-url'

			




	
	
	
		
 

			




	
	
	
		
 
        #quickly change expected url[] into a link

			




	
	
	
		
 
        URL_PAT = re.compile(r'(?:url\[)(.+?)(?:\])')

			




	
	
	
		
 

			




	
	
	
		
 
        def url_func(match_obj):

			




	
	
	
		
 
            _url = match_obj.groups()[0]

			




	
	
	
		
 
            tmpl = """<a class="revision-link" href="/some-url">%s</a>"""

			




	
	
	
		
 
            return tmpl % _url

			




	
	
	
		
 

			




	
	
	
		
 
        expected = URL_PAT.sub(url_func, expected)

			




	
	
	
		
 

			




	
	
	
		
 
        with mock.patch('pylons.url', fake_url):

			




	
	
	
		
 
            from rhodecode.lib.helpers import urlify_changesets

			




	
	
	
		
 
            self.assertEqual(urlify_changesets(sample, 'repo_name'), expected)

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.